architecture

When your tool depends on the host, declare the dependency at the gate. Don't wrap it. Don't patch around it.

Nous Research shipped an open-source personal agent that does most of what my bespoke system does. Here is what they got right, what they traded away, and what I stole.

Self-improving AI agents sound like the dream. But auto-generated knowledge is cheap, and cheap knowledge plateaus. The agents that compound are the ones someone tends.

Garry Tan's gstack arrived at the same architectural decisions I did, independently. The convergence matters more than either implementation.

A Chinese article argues CLI is becoming the AI plugin format. I've been living this for months with 442 tools. The article is right about CLI. It's wrong about what makes CLI work.

A simple rule for keeping AI agent skill systems coherent: if two skills fire on the same trigger, merge them. Different trigger, different skill. No exceptions.

When choosing CLI vs MCP, pick the one you can undo. CLI wraps into MCP cheaply. MCP does not unwrap.

Anthropic shipped a hosted agent platform. Its architecture looks familiar. Here's what a solo builder can learn from how they decoupled the brain from the hands.

Smart model plans, cheap model builds. The pattern everyone's converging on for AI coding agents — and the piece nobody's shipped yet.

Three independent authors converged on nearly identical patterns for CLIs that AI agents invoke. Here's what they agree on, what's missing, and why nobody has built a framework for it yet.

Willison says CLIs beat MCP. Cloudflare says server-side code mode beats both. They're both right, because they're answering different questions.

I designed an elegant framework install for my personal AI system. Then I listed the hard problems and shipped a three-hour cleanup instead.

Engineering metaphors give you clean abstractions. Biology gives you resilient ones. Twenty design heuristics from four billion years of R&D.

The tool/skill distinction isn't a property of the capability. It's a property of the context it operates in.

I ran an autonomous agent loop overnight — 43 waves, ~270 dispatches, ~250 vault files produced. Here's what I learned about building systems that work while you sleep.

We cut from 181 skills to 35 and added a 15-row routing table. Behavior improved across the board. The lesson: meta-skills compound, tool wrappers just add.

With 1M context windows, token savings are rounding error. The real metric is P(right tool | user intent) — does your agent reach for the right tool at the right moment?

In AI agent systems, use the most reliable trigger mechanism that fits — most builders default to skills for everything, which is using the weakest mechanism as the default.

Skills and MCP servers aren't competitors. They're different stages of the same lifecycle. Build the procedure as a skill first. Graduate the tool parts to MCP when they stabilize.

Agent knowledge systems have three fundamental paradigms: static context, dynamic tools, and retrieval. Most stop at two. The third is the biggest unexploited opportunity.

Every AI coding platform has mechanisms designed for specific purposes. Using them as intended beats clever hacks — and the reason is deeper than cleanliness.

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.

It's not enough to say humans are in the loop. You need to show the loop is in the system.

MCP decouples the tool from the model. Once that happens, the durable asset isn't the model — it's which systems you've exposed.

LangGraph is the SAP of agent orchestration — powerful at scale, overkill for most. Here's the line.

Most AI workflows are parallel-then-aggregate, not agent graphs. Knowing the difference saves you from framework theatre.

In AI agent architecture, calling something a 'cross-cutting concern' without naming an owner and a gate is just a polite way of saying nobody owns it.

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

Most enterprises are optimising the wrong variable. The gap between 5% and 40% agent adoption won't be closed by better models.

One of the architects of modern deep learning just raised $1B on the thesis that token prediction can't reach real reasoning. Here's what he's proposing instead — and why it matters even if he's wrong.