Blog

DeepReinforce trains a coding model that learns its own agent harness. I tested the 9B and 35B locally on an M3 Max. The idea is strong, the benchmarks are self-reported, and the biggest stumbling block sits in the packaging.

Agent memory is an architecture problem, not a toggle. An ordered overview: the cognitive memory functions, why the context window is not memory, RAG through GraphRAG with their real costs, and where n8n hits its native limits.

For the finale we place the local agent where Claude or ChatGPT usually sit inside Xcode. Apple showed the local provider slot at WWDC26, and we installed macOS 27 and Xcode 27 on purpose to put it to the test. How far does the borrowed small model get there? Article 13 of the series "A Local Coding Agent with apfel".

The series finale: n8n binds to its own service on SAP BTP with a real OAuth flow. Client Credentials against the xsuaa token endpoint, a CAP service as a SAP-native stand-in, the n8n OAuth2 credential, and a workflow that enriches a ticket with a case ID from BTP.

Gemma 4 12B is celebrated as the most complete local model. For Python I ran three variants against each other on an M3 Max, with real code execution, including a parser that defeats all three.

MTPLX promises noticeably faster local LLMs on the Mac via Qwen 3.6's built-in MTP heads. Measured on an M3 Max, with real numbers instead of marketing claims.

Microsoft celebrates Majorana 2 as a 1,000 times more stable quantum chip. Its foundation is Majorana quasiparticles, whose existence physics has not settled to this day. An assessment with technical background and sources.

QuEra wants to ship a fault-tolerant quantum computer with more than 256 logical qubits in 2028. The lever is not exotic physics but error correction with unusually little overhead. An assessment with technical background and sources.

Eleven articles covered what n8n can do. This one places where it does not belong: against SAP Cloud Integration with its EAI heritage and the Edge Integration Cell with its data boundary. With a decision tree instead of a tool takedown.

Operation goes production-ready. This article moves the single-process instance to queue mode: main accepts webhooks and enqueues executions in Redis, workers run them. With worker scaling, queue metrics, a production checklist, and a note on what queue mode does not do.

With @function you define your own CSS functions. The real novelty is not that CSS rebuilds Sass, but that a CSS function decides in the browser instead of at build time.

The pipeline now enriches its tickets with master data from a SAP backend. This article shows the OData binding over HTTP, SAP's own error format, graceful degradation on an unknown customer, and where AIF stays complementary.

Three days after launch, an export-control directive forces Anthropic to disable Fable 5 and Mythos 5 for all customers. What happened, why, and what it means.

ChatGPT sounds thoughtful. Claude sounds empathetic. And yet nobody is home. A mechanistic, philosophical and societal look at the difference between language models and consciousness.

With the Containerization architecture and the new Container machine, Apple has spent two years building a native Docker alternative for the Mac. A technical analysis of who is really under attack.

The agent gets a third surface. Behind a Hummingbird server it streams its work into the browser over Server-Sent Events, confirmation by click included. The same core as in the terminal, only a different sink. Article 11 of the series "A Local Coding Agent with apfel".

The local agent runs without a key and without the cloud. But what does that independence rest on? Two releases from the same week, a cloud handoff from Anthropic and Apple's MLX stack, bring the question into focus. A sober assessment. Article 12 of the series "A Local Coding Agent with apfel".

MCP moves writing tools out of the agent into separate servers. We build a small MCP server, attach it to apfel, and measure what MCP solves and what it doesn't. Article 10 of the series "A Local Coding Agent with apfel".

A single AI backend degrades to the rule-based emergency exit on failure. This article builds real redundancy from two local models: round-robin in normal operation, automatic failover on a single outage, rule-based only when both are down.

The one-shot command becomes an interactive REPL session. The key to testability is the strict separation of render logic and terminal I/O. Article 9 of the series "A Local Coding Agent with apfel".

An overview of the WWDC26 Platforms State of the Union: the Foundation Models framework opens up to server models and goes open source, the new Core AI brings your own models on-device, and Xcode 27 puts agentic coding at the center.

Two months after warning that Mythos was too dangerous to release, Anthropic makes the Mythos class public. A look at Claude Fable 5 and Mythos 5 between benchmark records, pricing tactics, and 30-day data retention.

The naive agent loop ends when the model goes quiet, and that is just a self-report. We build a loop whose stop condition is a machine check, with an iteration limit and a context budget as guards. Article 8 of the series "A Local Coding Agent with apfel".

Until now two separate paths ran side by side: the rule-based ingest and the AI classification. This article merges them into one pipeline, makes classification a swappable stage, and positions the rule-based classifier as a deliberate fallback behind the model.

At WWDC26, Apple shows how MLX distributes large language models across multiple Macs. RDMA over Thunderbolt 5, the JACCL library, and a cluster of four M3 Ultras running a trillion-parameter model locally.

Anthropic released a Swift package that wires Apple's Foundation Models framework to Claude. The interesting part isn't Claude in an app — it's the handoff pattern: on-device for fast and cheap, Claude for the hard part.

The naive file edit fails on the small model. We build the agent around that weakness, with constrained output and a two-stage edit workflow, and measure how much can be recovered. Article 7 of the series "A Local Coding Agent with apfel".

A reproducible eval of 15 tasks across five categories measures where the local Foundation Model carries as a coding agent and where it breaks. With a cloud sample and a separate measurement of what the model claims about its own success. Article 6 of the series "A Local Coding Agent with apfel".

The AI classifier runs, but what happens when the model goes down? A global error workflow with a Telegram alert, an observability stack of Prometheus, Loki and Grafana, and a silent fallback that wants to be made visible.

We build the first tools the agent uses to change things, and lock them down — a path sandbox, a confirmation gate, a diff before writing, and defense-in-depth for the shell. Article 5 of the series "A Local Coding Agent with apfel".

We teach the agent to call tools — the tool definition in the OpenAI schema, the round-trip of invocation, execution and continuation, and a tool abstraction in Swift. Article 4 of the series "A Local Coding Agent with apfel".

Within a few weeks, two open-source tools have set out to solve Claude Code's memory problem. But they don't solve the same problem — Graphify builds a code graph, MemPalace stores the conversation.

A research preprint demonstrates a computer worm that runs a local language model on hijacked machines and devises its attacks per target. What is new about the proof of concept, what is not, and why patch management alone is no longer enough.

Cross-document view transitions bring app-like navigation to classic multi-page sites — with a single CSS at-rule and no framework at all.

We set up a Swift package, build an async HTTP client against apfel --serve and process SSE streaming token by token — Article 3 of the series "A Local Coding Agent with apfel".

We start apfel as a local OpenAI-compatible server, walk through every endpoint and see where the protocol diverges from OpenAI — Article 2 of the series "A Local Coding Agent with apfel".

We install apfel, walk through the three modes (prompt, serve, chat), and see where the on-device model holds up and where it gives way — Article 1 of the series "A Local Coding Agent with apfel".

A series takes a close look at the Foundation Model every Apple Silicon Mac running macOS 26 ships with — and builds on it a coding agent in Swift that runs locally.

The TeamPCP incident from May 2026 shows how a tampered VS Code extension led to the exfiltration of around 3,800 internal GitHub repositories — and why the problem is not GitHub but the trust model of modern developer environments.

How an n8n workflow classifies tickets with a local language model: structured output, two backends without a cloud key, deterministic language detection, and a benchmark that exposes its own weakness.

Anthropic has released Claude Opus 4.8: same price as 4.7, a clear jump in coding and reasoning, a measurably lower tendency to let its own code flaws slip by, and dynamic workflows with hundreds of parallel subagents.

How an n8n workflow gets an authenticated webhook endpoint, how credentials are stored securely, and how classifier logic is extracted into a sub-workflow.

Building a rule-based ticket classifier in n8n: the item model in practice, writing expressions correctly, choosing between Set and Code nodes — and where the classifier predictably fails.

Bonus article of the series — how the byhaushalt demo parser holds up against two independent sources: the official EPL PDFs from the Bavarian finance ministry and the interactive budget diagram at stmfh.bayern.de. Σ revenues and Σ expenses match the PDF Σ to the cent; the residual difference against STMFH is data-vintage-related.

Article 10 of the series — how a Vite SPA in the repo becomes a live site on a custom subdomain. Branch protection for solo projects, a Bash script that fills the pages branch via git worktree, custom domain via DNS CNAME plus .domains file, HTTPS via Let's Encrypt. And why CI deliberately gets its own follow-up article.

Why a real ticket dataset has no place in a public repo, and how a hybrid generator using local models and Claude produces realistic test data with a reproducible distribution.

Self-hosting n8n in a production-grade setup: Docker Compose, Postgres instead of SQLite, Caddy with auto-HTTPS, persistent volumes, and the environment variables that actually matter.

What n8n actually is under the hood: editor, execution engine, task runners, workflows as JSON. Plus the item array as the central data model and where n8n fits in the integration landscape.

Article 7 of the Hummingbird series. We measure the LLM gateway against functionally equivalent implementations in FastAPI and Fastify — with a fair middleware stack, a deterministic backend stub, and oha as the load generator. The results are both what you expect and somewhat surprising.

Article 6 of the Hummingbird series. We add Prometheus metrics via swift-metrics and swift-prometheus, a /metrics endpoint, MetricsMiddleware and TracingMiddleware. Plus: cross-compiling to a statically linked Linux binary via the Swift Static Linux SDK, a multi-stage Dockerfile, and a systemd unit for bare-metal Linux deployment.

Article 9 of the series — three hooks for byhaushalt: PostToolUse formats after every edit, PreToolUse blocks commits with debug leftovers, Stop runs fast tests but only for changed layers. Why an overly aggressive Stop hook does more harm than good, and why Playwright belongs in CI, not in a hook.

SAP has taken a strategic stake in n8n and embedded it in Joule Studio. Mercedes-Benz is rolling out the platform globally. A prologue to the n8n getting-started series.

Article 8 of the series — Markdown spec as E2E test contract: Claude reads the user flow, explores live in the browser via Playwright MCP, finds robust selectors, and writes the Playwright test. Three specs, three tests, three baseline screenshots.

Article 5 of the Hummingbird series. We add API key auth, token-bucket rate limiting, and spec-compliant error responses — using Hummingbird 2's generic RequestContext to carry typed middleware state without dictionaries.

Article 7 of the series — two MCP servers, one project configuration: Context7 fetches current library documentation directly into the editor before Claude has to guess. Plus a shadcn/ui migration and a chart-builder skill that calls Context7 deliberately.

Article 6 of the series — three worktree branches, three visualizations over the same data model. Treemap, sunburst, and Sankey compared side by side rather than guessed at sequentially. Plus: why the decision in the end was not against two losers, but in favor of a switcher.

Article 4 of the Hummingbird series. We add streaming to both endpoints via Server-Sent Events: MLXClient.completeStream as AsyncThrowingStream, Anthropic events, OpenAI chunks, task cancellation. Tokens appear at the client as the model generates them.

Article 3 of the Hummingbird series. We connect the gateway to mlx_lm.server: MLXClient as a Swift actor, format conversion from Anthropic to OpenAI, error mapping with HTTP status codes. After this article, the gateway delivers real model responses.

Article 2 of the Hummingbird series. We implement the Anthropic Messages API and the OpenAI Chat Completions API in the same gateway: Codable types for both protocols, two POST endpoints, input validation, mock inference.

Article 1 · Swift on the Server with Hummingbird. We create the project, write Package.swift, set up the AsyncParsableCommand entry point, and build a minimal router with /healthz and /v1/models until curl gets an answer.

Article 5 of the series — v0.4 delivers three JSON files, not a data model. A plan file with three tasks and parallel subagents builds schema, normalization, and property-based tests. Plus: what format inconsistency teaches about parallelization.

Prologue · Series: Swift on the Server with Hummingbird. Why Swift on the server is no longer a hobby project in 2026, how Hummingbird differs from Vapor and why we chose a local LLM gateway as our demo project.

SAP announced the ABAP MCP Server at Sapphire 2026 — the technical foundation for plugging external AI agents like GitHub Copilot, Amazon Q, or Claude Code directly into ABAP development. A look at what the announcements mean technically, what they will cost, and where the gaps remain.

Article 4 of the series — three slash commands make the parser repeatable: /parse-epl for any Einzelplan, /check-totals with built-in pytest, /diff-vs-gesamt for comparison against the full budget. Plus: what xfail reveals about parser gaps.

Article 3 of the series — the first parser code for byhaushalt takes shape via TDD: a custom skill with trigger description, uv setup, six tests before implementation, and how the sum consistency test catches hallucinations in PDF parsing.

Article 2 of the series — before byhaushalt sees its first parser code, Claude Code maps the PDF structure of the Bavarian budget plans. Plan Mode, Explore subagent, and Architecture Decision Records as tools for exploring before implementing.

Article 1 of the series — we install Claude Code, set up the byhaushalt repo, write the first memory file, and pin down what the agent has to follow in every session. Plus: permissions, source data, the first day.

Prologue · Series: Agentic Coding with Claude Code. Anyone reading tech newsletters, conference keynotes, and tool landing pages this year runs into two terms sold with identical promises: Vibe Coding and Agentic Coding. The future of programming, they say.

A new LLM out of Miami promises 12 million tokens of context, linear scaling and a 52× speedup over FlashAttention. We take a close look at what's technically behind it — and where reasonable skepticism kicks in.

Eight articles of theory, one bonus chapter of practice. We combine all the code fragments from the LLM series into a working mini language model, train it on TinyShakespeare, and tack on a tiny SFT step. With a wink to Star Trek TNG.

How a base model that completes text becomes a helpful assistant. Supervised Fine-Tuning, RLHF, DPO, and Constitutional AI — the last piece of the LLM pipeline, with the candid question of what alignment actually solves.

Claude Desktop registers a Native Messaging bridge in seven browser directories without asking — even in browsers that aren't installed. What it means technically, why it violates the ePrivacy Directive, and why Anthropic of all companies is squandering trust here.

Position, depth, stability — what gets added on top of attention to make a complete transformer. Positional encodings, feed-forward layers, residual connections, layer normalization, the entire block in Python, and the leap to GPT, BERT, Llama, and Claude.

Microsoft's 'Windows K2' initiative is meant to save Windows 11 — but doesn't address the root problem. Why Apple is the most plausible answer, and why Linux deserves an app-store approach that doesn't depend on the distribution underneath.

A step-by-step migration strategy away from GitHub, with a focus on CI pipelines. Concrete workflow translation, self-hosted runner setup, why OSS and proprietary builds must not share runners, and a checklist you can tick off.

Tagesschau is shutting down its Apple Messages for Business channel and pointing recipients exclusively to a WhatsApp channel. A license-fee-funded broadcaster is migrating from a privacy-friendlier messenger channel to a markedly more problematic one — and ignoring platform-neutral alternatives along the way.

How the bottleneck of RNNs was replaced by a mechanism that links every token to every other. Query, Key, Value, Multi-Head, and the paper that flipped the NLP world, explained with library metaphors and just enough math for the curious.

A commentary on the Signal phishing affair, the reflex response from a Bundestag Vice President — and the very loud silence of the Digital Minister.

Which code hosting platforms operate without default-on data processing? Comparison table, platform profiles from Codeberg through Gogs and Launchpad to AWS CodeCommit, plus a concrete TDM opt-out implementation.

Since April 24, 2026, GitHub uses Copilot data from Free, Pro and Pro+ accounts for AI training by default. What's behind the change and why it exposes the platform's two-class model.

Why language needs memory, and how the first language models learned that context. Recurrent networks, LSTMs, and the long-sentence problem, explained without a formula storm.

An independent look at GPT-5.5, released April 23, 2026. What the numbers really say, where Claude Opus 4.7 still leads, and why the pricing trajectory should worry developers.

Windows has become a design flaw. Copilot, Recall, TPM sniffing, plus a cloud strategy that costs productivity instead of delivering it. Macs are the rational choice in business. The software argument no longer holds in 2026.

How neural networks learn from errors. Loss, gradients, chain rule, gradient descent — backpropagation implemented by hand on a 2-layer MLP that learns XOR and token prediction.

What happens between embedding and logit. Neurons, layers, forward pass, and activation functions — fully implemented in numpy, no framework magic.

How language models encode meaning in numbers. Embedding tables, cosine similarity, vector arithmetic, and why King minus Man plus Woman equals Queen.

What happens between input and output? Tokens, probability distributions, and sampling strategies — explained step by step, with real code.

Anthropic releases Claude Opus 4.7 with significantly better coding performance, 3.75 megapixel vision, and a new xhigh effort level. An assessment of the benchmarks and the Mythos hint on the side.

The coalition cuts the fuel tax and calls it relief. Nothing changes at the pump — except the profit margins of oil corporations.

An open-source tool that outclasses commercial AI memory solutions — using a 2,500-year-old method, running locally, free, and open source.

Anthropic's Claude Mythos broke out of a sandbox and found thousands of zero-days. An assessment between real risk, methodological gaps, and strategic narrative control.

Why local language models are becoming a real alternative in 2026 — MLX, Unified Memory, and a stack that works without the cloud.

An Obsidian plugin for bidirectional synchronization with BookStack — built with Claude Code as a structured development partner.

Horizontal grids with sections, collapsible lists, star rating with mask, and tap feedback without Button.

The default ColorPicker is a tiny circle. With blur, scaleEffect, and opacity 0.014, you can turn it into a fully customizable button.

Reusable modifiers as View extensions. One design change, one place in code.

The inline Picker swallows its label. A Menu wrapper fixes the problem. Plus: a generic Enum Picker for less boilerplate.