agents

The larger the system, the less it can be managed and the more it must be emerged. This pattern — from water to ant colonies to AI agents to economies — reveals the design principle for scaling autonomous systems.

The right organisational metaphor for AI agent teams isn't a company with managers and reports — it's a colony with autonomous workers responding to coordination signals.

The governance patterns for autonomous AI agents are the same ones good managers already use: cadence reviews for normal flow, escalation channels for urgent anomalies, and human judgment only where it has maximum information value.

The AI governance conversation is stuck in the wrong frame. The pattern that works isn't autonomous agents — it's exoskeletons. Micro-agents handling narrow tasks, with human judgment at every point that matters.

What Grove, Drucker, Deming, and Weinberg knew about managing humans turns out to apply — with surprising specificity — to orchestrating AI agent teams.

The research on multi-agent AI systems was mostly done on cheap models. Now that frontier models are the ones people actually use, we might be optimising for the wrong game.

OpenClaw's 245 CVEs weren't caused by malice — they were caused by a missing circuit breaker. The pattern applies to every AI agent you'll ever evaluate.

SR 11-7 assumes models are tools that produce outputs for human review. AI agents are actors that take actions autonomously. Every assumption breaks.

Every AI governance framework demands human-in-the-loop. Nobody does the maths on what that means at enterprise scale.

Search returns summaries. Get returns detail. The model decides what to expand. 75% context savings.

Interaction, inference, orchestration, tooling. The boundaries between them must be enforcement points, not design principles.

The companies that win with AI agents aren't deploying the most agents — they're redesigning their organisations to work with them.

Not tools that search your notes — personalities that live in them, form opinions, and disagree with each other.

Most LLM pipelines don't need agents. The ones that do share a specific pattern — the step needs to decide what to do next, not just process what it's given.

Which parts of an AI dev workflow can be wrapped in a CLI, and which can't — learned the hard way by building the wrong thing and measuring it.

Karpathy's autoresearch and every useful AI tool share the same pattern: the code is trivial, the feedback loop is the product.

Every AI lab builds single-vendor orchestration. The cross-vendor layer is a gap — and it's a gap for a reason.

Multi-agent AI orchestration frameworks are commodity. The competitive advantage is knowing which agent to use when, what breaks, and how to recover.

Prompt instructions are suggestions. Hooks are constraints. One survives a model swap.

The retrieval pipeline was built for systems that couldn't reason about their own information needs. Agents can.

AI coding agents didn't just make developers faster. They changed who gets to have a bespoke system.

AI agent results should be push, not pull. The feedback loop should close on mobile. Most tools miss all three — not from ignorance, but because dashboards photograph better.

I kept missing things at the end of AI sessions. So I stopped relying on willpower and systematised the nudge instead.

Sequoia says AGI is here. Dan Shipper says we're not there yet. They're both right — they're measuring different things. The question that actually matters is Sholto Douglas's "nines of reliability."