Archives

celld, a new open-source project from Deno, reimplements Cloudflare's Durable Objects model on infrastructure you own — and it's a good lens for asking what should actually own an AI agent's state.

AI agents are stateful, long-running, and mostly idle. That's not a quirk — it's a specification. The actor model was built for exactly this shape of work.

Most RL writing is about algorithms. In practice, environment design — the state, action, and reward decisions that sit between your system and the algorithm — is where projects succeed or fail. This is the part that almost never gets covered.

The orientation for working engineers before the rest of the series goes into algorithm internals. What RL is, the vocabulary, the Bellman idea, when to reach for it, and a map of the five posts.

Bellman equations are usually introduced recursively, and the recursion misleads programmers. The runtime is closer to iterative graph relaxation — value sweeping backward through a state graph until it stops moving.

An LLM in a loop is not enough for production work. This post breaks down the six problems every agent harness must solve — working memory, shared file access, plan/execute modes, task tracking, parallel sub-agents, and tool approval — and how the Microsoft Agents Framework implements them.

How to secure Model Context Protocol (MCP) tool usage in sequential agent workflows using Supply Chain Validation and Least-Privilege Sandboxing.

How to secure distributed multi-agent architectures using Zero-Trust Identity, IATP encryption, and Dynamic Trust Scoring in the Agent Governance Toolkit.

How to use the Microsoft Agent Framework (MAF) and Agent Governance Toolkit to build secure, governed, and Human-in-the-Loop AI workflows.

What actually happens inside one iteration of the ReAct loop — why the model is stateless, how the transcript grows, when the loop exits, and why the harness around the model is where the engineering value lives.

Google's developer guide to AI agent protocols is framed as a tutorial. Read it through a Coasean lens and it's something more interesting — live evidence that the transaction costs making firms necessary are being eliminated, layer by layer, in the open.

Returning to Coase's original question — why do firms exist? — with fifteen posts of new machinery. The answer has not changed. The composition of the costs has.

The shift from hierarchy to protocol-governed agent coordination is not theoretical. Over fifty companies are engineering it now. Here is what the early evidence tells us.

Protocols define how participants interact. Value streams define why. By mapping the flow of outcomes rather than the structure of teams, we align architecture, organisation, and network around the same thing: how value is actually produced.

Queuing theory reveals the hidden physics governing how work flows through organisations. Every boundary is a queue. High utilisation destroys responsiveness. And AI agents change the service rate — but not the dynamics.

How networked firms coordinate work through protocols instead of hierarchy.

Not all networks scale the same way. The geometry of a network — broadcast, connection, or group-forming — determines how its value grows, and which institutions it produces.

Metcalfe's Law governs the value of the external network, while Conway's Law governs the structure of the organization that builds and operates it.

We are witnessing the collapse of the corporate Tree into the Hybrid Mesh. As intelligence becomes infrastructure, the distance between strategy and execution shrinks to a single, high-density hop.

Firms do not only coordinate production. They concentrate knowledge. Innovation has historically depended on short-distance diffusion through dense networks.

Software first reduced coordination costs. Now autonomous agents begin to execute parts of labor itself. This changes the structure of work without eliminating it.

Platforms are not the disappearance of the corporation. They are a reconfiguration of how coordination occurs within a corporate shell.

If firms exist because coordination is costly, what happens when coordination becomes cheaper again? The boundary of the firm is not fixed.

When coordination costs shift, firm boundaries should adjust. But mature corporations are optimised for a cost structure that no longer holds — and their own incentives prevent adaptation.

The managerial corporation solved coordination at scale. But hierarchy has structural limits — and the same mechanisms that enabled growth eventually constrained it.

Corporations did not just reduce transaction costs. In the 20th century, they became the dominant institution for organising production, concentrating capital, and coordinating labour at scale.

Corporations did not emerge by accident. They are coordination machines. In 2026, as transaction costs fall, we revisit why they exist — and what might be changing.

Metrics don't measure reality — they project it. As systems become more autonomous, projection design matters more than model intelligence.

Execution, collaboration, and ecosystems: three edges where agent innovation is actually happening — and what it means for building durable, human-centered systems.

Agent workflows feel new, but the stability problems they face are not. Here's how decades of integration architecture apply to building production agent systems.

Three patterns for keeping LangGraph workflow state and database state synchronized - idempotent tasks, read-before-write synchronization, and the transactional outbox pattern.

An Intuitive Journey Through Statistics & Hypothesis Testing in a coffee shop

Translate the maths you see in ML papers into code you can write. A compact cheat sheet mapping notation → intuition → Python/NumPy (and JS).

Building Agent Networks that Don't Collapse Under Their Own Cleverness

Agents Are Just Software Why the Next Wave of AI Is Really a Distributed-Systems Story.