// Topic
AI Agents
Agents are useful only when they are bounded by real workflows, explicit tools, and operational checks. The writing here treats agents as production systems, not autonomous magic.
Start Here
- Building Reliable AI Agents in Go covers bounded tools, validation, recovery paths, and failure containment.
- Agent Orchestration: Four Patterns, Honest Tradeoffs compares the orchestration shapes that actually survive production.
- Agent Architecture Patterns That Actually Work in Production gives the foundational model for tool use and control flow.
What Makes Agents Production-Ready
An agent is production-ready only when the system around it is boring:
- Tool access is scoped and auditable.
- Human approval exists where blast radius is high.
- Outputs are validated before downstream actions.
- Retries and fallbacks are explicit.
- Cost and latency are measured per workflow, not per demo.
Reading Path
For orchestration decisions:
- AI Workflow Automation: Decisions Are Cheap, Actions Are Expensive
- Agent Patterns That Survive Production
For architecture boundaries:
For governance and reliability:
Failure Modes
- Giving an agent broad tool access before defining approval boundaries.
- Treating orchestration as a prompt problem instead of a state-management problem.
- Measuring success by task completion while ignoring retries, escalations, and silent failures.
- Letting every team invent its own agent framework, logging format, and evaluation path.
Related Hubs
References
6 posts
- Building Reliable AI Agents in Go
Reliable agents aren't prompted into existence. They're engineered -- with bounded tools, validation at every step, explicit recovery paths, and the same discipline you'd apply to any production system. Here's how I build them in Go.
AI Workflow Automation: Decisions Are Cheap, Actions Are Expensive
The trick to AI workflow automation is simple: let the model decide, let deterministic code act, and never confuse the two.
Agent Orchestration: Four Patterns, Honest Tradeoffs
Multi-agent systems aren't magic. They're distributed systems with all the usual coordination headaches. Here are the four patterns I've seen work, and when each one falls apart.
Agent Patterns That Survive Production
Single-prompt agents break on real tasks. Plan-execute-replan, orchestrated specialists, structured memory, and explicit recovery -- in Go -- are what actually works.
Agentic Workflows: From Demo Magic to Production Reality
AI agents that can take actions are fundamentally different from chatbots. The engineering bar must match the blast radius.
Agent Architecture Patterns That Actually Work in Production
Most agent demos are impressive. Most agent production systems are not. Here is what separates the two.