Ki

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.

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.

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.

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".

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.

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.

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.

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 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 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.

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.

Starting with macOS 17, third-party apps can use MLX directly as a system framework.

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