How Much Infrastructure Does an AI Agent Need?

Over the past six months, helping dozens of teams evaluate “going Agent,” we heard two extremes most often: either they bought only a model API and expected it to edit production alone; or they deployed Kubernetes + a vector DB + three MCP servers + an autonomous Agent platform—and nobody maintained it three months later. What actually blocks delivery is rarely “the model isn’t smart enough,” but misaligned execution environment, verification chain, and context gateway. This article uses Cloud Mac AI Stack layering to turn “how much infrastructure does an AI Agent need?” into decision tables—you can match your team size instead of copying someone else’s architecture blog shopping list.

1. Why this problem exists: “can chat” ≠ “can ship”

After “Agent” became overloaded, many conflate chat interfaces with engineering Agents. Chat needs only a model API; engineering Agents must at least read the repo, edit files, run commands, and get objective verification signals. Missing any piece shows up as:

• Agent edits code but nobody knows if tests ran—missing L1 Fact (Runner execution engine).
• Agent only edits the open file; cross-module refactors are guesswork—missing L4 Context (MCP triple-connect).
• Every tool works alone but a whole issue still needs 40 minutes of babysitting—missing L5 Workflow (OpenHands platform).
• On a Windows laptop you want Xcode builds but the Agent has no legal execution surface—missing L0 real macOS (Cloud Mac vs local Mac).

The old reflex is “buy a stronger model”; the new one is fill execution and verification layer by layer. This is what ZavCloud customers ask when renting Cloud Mac—not whether RAM runs Ollama, but what role this node plays in the stack.

2. How to classify Agent infrastructure: six layers, not six products

We use L0–L5 (consistent with the Stack series). Note: layers are responsibilities, not a mandatory shopping list. Solo devs can stop at L3; L2 inference (Ollama) is optional throughout.

The conflict is clear: chat Agents stop before L3; engineering Agents need at least L0+L3; mergeable Agents need L1; scalable Agents discuss L4+L5. Many teams fail by skipping layers—e.g. OpenHands before Runner, so autonomous tasks change code with nobody proving build green.

3. Core comparison: solo / small team / engineering tiers

Unified columns (same as tool comparison articles): entry, execution, context, monthly cost band, best fit.

Hardware: when L0 and L1 share one machine (common), use this table—RAM hits the ceiling before CPU model because Agent, Runner, and optional Ollama contend for unified memory:

4. Scenario matrix

Quick triage with “if you are X, choose Y”:

5. Recommended stacks: three copy-paste recipes

Stack A · Fastest solo launch (within 1 day)

L0  Local MacBook or pay-per-day Cloud Mac
L3  Claude Code (install handbook)
Model  Anthropic API subscription

Skip: Runner, MCP, vector DB, K8s

Stack B · Small team mergeable (1–2 weeks)

L0  Cloud Mac M4 16GB always-on node
L1  GitHub Actions self-hosted Runner (worth it?)
L3  Claude Code + team CLAUDE.md
L4  GitHub MCP read-only (issue-driven)

Optional L2: Ollama 7B for private drafts, off critical path

Stack C · Engineering autonomous delivery (1 month+)

L0  Cloud Mac M4 24GB+
L1  Runner · one job one workspace
L3  Claude Code
L4  MCP triple-connect + CodeGraph
L5  OpenHands (sandbox repo first)
Orchestration  OpenClaw triggers + audit (optional)

Red line: prod API / Runner creds never in MCP (permissions guide)

6. Common mistakes: five don’ts

1. Treating model API as full infrastructure. API solves “think,” not “do” and “verify.”
2. Opening L5 repo writes without Runner. Autonomous Agent without Fact layer is blind writing—rollback cost is extreme.
3. Building vector DB + RAG platform on day one. Most code Agent bottlenecks are symbolic context (CodeGraph), not embedding search.
4. VM on Windows posing as macOS CI. Signing, notarization, and device tests still need real Apple Silicon.
5. Buying someone else’s full shopping list. Write execution boundary first, add layers incrementally; stack depth ≠ team headcount.

7. Rollout: 7-step checklist

1. Define execution boundary — List allowed Agent actions: which dirs, shell, prod triggers.
2. Confirm L0 — Xcode / notarization needs macOS; evaluate rent vs buy Mac.
3. Add L3 coding Agent — Single file, single repo first; write CLAUDE.md / team prompt norms.
4. Stand up L1 Runner — Separate macOS and Linux jobs; split secrets from Agent tokens.
5. Add L4 MCP as needed — Read-only default; write via short-lived token on separate service.
6. Evaluate L5 — Two weeks still manually chaining tools → add OpenHands-class Workflow.
7. Audit and red lines — Map every autonomous task to PR + CI run ID; quarterly permission matrix review.

FAQ

Conclusion

How much infrastructure an AI Agent needs depends on where the execution boundary stops—not the model leaderboard. Solo: L3 is enough to start; orgs that must merge add L1; large repos add L4; unattended delivery adds L5. When buying Cloud Mac or Mac mini, ask whether the machine is “execution surface,” “verification surface,” or “inference surface”—that beats staring at TOPS numbers.