The AI Agent Tech Stack Behind 325 Agents in Production

There's a Reddit thread sitting at the top of the search results for "what tools to use to build AI agents." Read through it and you'll find the pattern every framework roundup falls into: a list of vendors, no mention of why any of them exist. LangChain vs. LlamaIndex vs. CrewAI, pick your poison, good luck.

That's not a stack. That's a shopping list.

I run 325 agents in production — cron-triggered specialists, on-demand builders, content pipelines, review swarms — and the honest answer to "what tools" is that the tools matter less than the layers underneath them. Every agent still running six months after I built it sits on the same AI agent tech stack: orchestration, tool-calling, memory, a harness, and observability. Skip a layer and you don't get a simpler system. You get a specific, predictable failure.

This is that stack, layer by layer, and the failure each layer exists to prevent — not a vendor comparison chart. AI Agents in Production makes the broader case that building agents was never the hard part; operating them was. This is the infrastructure that makes operating them possible.

Why the Reddit Thread Gets This Wrong

The top answer in that thread is a tool list: pick an orchestration framework, pick a vector database, pick a monitoring dashboard, done. It's not wrong, exactly — it's incomplete in the way every "here's my tech stack" post is incomplete. It tells you what to install. It doesn't tell you what breaks if you don't.

That gap is the actual demand signal. People aren't asking "what tools" because they're shopping. They're asking because their first agent worked for a week and then quietly started doing the wrong thing, or stopped running altogether, or burned a weekend's worth of tokens re-discovering context it already had. The tools didn't fail them. A missing layer did.

Five layers cover almost every failure mode I've hit running agents at this scale. None of them are exotic. All of them are skippable in a demo and expensive to skip in production. The demo doesn't punish you for skipping one — a demo runs once, in front of you, and you catch the problem live. Production runs unattended, on a schedule, at a scale where nobody's watching any single execution. That's exactly the condition each of these layers is built for.

The AI Agent Tech Stack, Layer by Layer

Orchestration: Who Wakes the Agent Up

The first question isn't "what can this agent do." It's "what makes this agent run." A chat-triggered agent only exists when a human remembers to open a session and ask. That's fine for one-off work. It's a liability for anything that needs to happen on a schedule — nightly audits, morning briefs, recurring cleanup — because the failure mode isn't a crash, it's silence. Nobody notices a cron job that never got written.

The orchestration layer is a persistent runtime that owns the clock instead of a human owning it: scheduled agents that fire on their own cadence, retry on failure, and stagger so twenty jobs don't collide on the same resource at the same minute. Once an agent's trigger is a schedule instead of a memory, it stops depending on anyone remembering it exists.

Tool-Calling: MCP as the Common Interface

Give an agent five tools and you write five integrations. Give ten agents the same five tools with no shared layer and you write fifty. That's the failure this layer prevents — not "agents can't call tools," but the integration explosion that happens the moment you have more than one agent and more than one tool.

The Model Context Protocol solves this by standardizing the interface instead of the tool. An agent doesn't need a bespoke wrapper for a search API, a filesystem, or a messaging bridge — it needs one client that speaks MCP, and any tool exposed as an MCP server is immediately usable by any agent that speaks it too.

{
  "mcpServers": {
    "your-search-tool": { "command": "npx", "args": ["-y", "@vendor/search-mcp-server"] },
    "your-memory-tool": { "command": "node", "args": ["memory-server.js"] }
  }
}

That's the whole registration. No custom SDK per agent, no per-agent auth dance. The tool-calling layer is what turns "an agent with API access" into "a fleet with shared capabilities."

Memory and Knowledge: Stopping the Cold Start

An agent with no memory relearns the same codebase, the same conventions, and the same mistakes every single session. That's not a minor inefficiency — it's the layer most people skip first, and it's the one that gets expensive fastest, because the cost isn't visible until you tally the tokens spent re-discovering context you already paid for once.

The fix is a memory and knowledge layer that survives a restart: what got tried and failed, what conventions the codebase actually follows, what decisions were already made and why. Once an agent can query "have I seen this before" instead of starting from a blank slate, the same class of mistake stops recurring across sessions instead of resetting every time.

The Harness: Guardrails Before Guardrails Are Needed

This is the layer that decides what an agent is allowed to do, not just what it's capable of doing. Capability without constraint is how an agent force-pushes to main, deletes something it shouldn't, or "helpfully" refactors code nobody asked it to touch. The harness is rules-as-code — a CLAUDE.md-style contract plus hooks that actually enforce it, not just suggest it:

## Hard Rules
- NEVER commit directly to main — feature branch + PR
- Run tests before declaring done
- 90% coverage floor
- Update lessons.md after corrections

A rule an agent can silently ignore isn't a guardrail, it's a suggestion. The harness layer is what closes that gap — hooks that block a disallowed action before it executes, not documentation that hopes the agent reads it. If you want the fastest way to stand up the testing half of this layer, the scaffold-tests skill sets up a real test pipeline — framework, CI workflow, coverage threshold — in one command instead of a day of scaffolding.

Observability: Seeing 325 Agents Without Watching Any of Them

At small scale you can watch an agent work. At fleet scale, watching doesn't scale — and the failure that replaces it isn't a crash, it's an agent that completes successfully while producing the wrong output, and nobody finds out for two weeks. No error, no stack trace, just quietly wasted work.

Observability closes that gap after the fact instead of requiring attention in the moment: what ran, what it cost, what changed, and whether behavior is drifting from what it was doing last month. You don't watch 325 agents. You watch the record they leave behind, and you look at it when something seems off.

Picking Your Stack Without the Vendor Whiplash

If you haven't built a single agent yet, don't start with all five layers — start with one agent and one job. How to Start Building AI Agents: From Zero to First Agent walks the actual on-ramp instead of the full production checklist.

Once you're past the first agent and choosing an orchestration and tool-calling framework specifically, the decision gets concrete fast — I break down where LangGraph, CrewAI, and Claude Code genuinely diverge in LangGraph vs CrewAI vs Claude Code: Picking an AI Agent Framework, instead of a feature-matrix that treats them as interchangeable.

None of this is theoretical. I built a working version of the memory and harness layers above in a single session — the whole build, including what broke along the way, is documented in Building an Agent Operations Platform in One Session. And the memory-layer idea specifically — agents that don't forget what they've already learned — is the same thesis behind tesseractintelligence.io's approach to decision intelligence: the value isn't the individual answer, it's the compounding record of decisions.

Start With the Layer You're Missing

You don't need all five layers on day one. You need to know which failure you're currently exposed to, and build the layer that prevents it. No scheduler means work silently doesn't happen. No shared tool-calling layer means integration debt compounds with every new agent. No memory means every session pays the same cold-start tax. No harness means capability outruns constraint. No observability means failures go unnoticed until someone asks why the output looks wrong.

The honest diagnostic is to look at whatever's currently annoying you about the agent you already have. If you keep re-explaining the same context, that's a memory gap. If you keep catching a bad action after the fact instead of before it, that's a harness gap. The stack isn't something you adopt wholesale — it's something you build one missing layer at a time, in the order your own failures are pointing at.

Start with the 7 free skills at jeremyknox.ai/skills-library — no signup. scaffold-tests alone will get the harness layer's testing half running in a repo that has none today.