15 Systems for Agentic AI Engineers: It Only Counts If It Runs

Suraj Sharma listed 15 projects on X with a very direct title: as an Agentic AI Engineer, you should build these. He later also gave a 6-month roadmap. Looking at both together reveals a tendency: the bar for agent engineering is not whether you can call a model, but whether you can make the system run reliably amid concurrency, failures, cost, permissions, and evals. Original tweet link: https://x.com/suraj_sharma14/status/2115413286829298029

15 Projects

1. Async Agent Orchestrator: FastAPI plus an asyncio event loop, handling 100+ concurrent agent tasks, supporting non-blocking tool calls and error recovery. Suraj's reasoning is that a while True loop blocks the main thread, and production traffic needs event-driven concurrency.

2. Dynamic Context Budget Assembler: pre-request middleware that allocates tokens among the system prompt, retrieved documents, and tool schema. Context overflow is the silent killer of production agents; tokens need to be managed like a cloud budget.

3. Strict Pydantic Tool Router: forces LLM output to conform to strict JSON schema, and automatically retries with error traces on validation failure. Agents will invent API parameters; syntax-constrained decoding and Pydantic validation turn random output into deterministic actions.

4. Three-layer Memory and Eviction Engine: working scratchpad, session compression, semantic vector retrieval, plus automatic TTL eviction. Infinite context brings OOM and hallucinations; memory needs active management, scoring, and pruning.

5. Self-healing ReAct Loop: the agent reads its own stack trace, parses compiler or API errors, rewrites the failed tool call, retrying up to 3 times. An agent that fails on the first try is useless; an agent that can debug itself starts to look like a digital employee.

6. Typed Multi-Agent Swarm: using a LangGraph state machine, let Researcher, Coder, and Reviewer pass strictly typed state objects, not raw text. A single agent fails at complex tasks; multiple agents can divide and conquer, but raw-text handoffs cause context drift.

7. Async HITL Slack Gate: the workflow first drafts high-risk actions, serializes state, and waits for a human to click 'Approve' via a Slack webhook, for up to 3 days. High-risk automation needs human accountability; agents need to know how to pause, wait, and resume.

8. Trajectory Eval CI Gate: a GitHub Action replays 100 agent trajectories; if the tool-call sequence deviates from the golden DAG, it blocks the PR. Looking only at final text hides the process where an agent fabricates API calls or skips safety checks.

9. OpenTelemetry Agent Tracer: custom tracing spans capturing every LLM hop, token count, tool latency, and state change, integrated with LangSmith or Arize. A 14-step agent workflow is hard to debug if it cannot be replayed.

10. Inter-Agent Sanitization Proxy: middleware intercepts messages between agents, strips malicious instructions, and prevents cross-agent prompt injection. Multi-agent systems create an internal attack surface; Agent A may be induced to hijack Agent B's tools.

11. Sandboxed Code Executor: code interpreter runs Python in an E2B or gVisor microVM with zero outbound internet. Letting an LLM run os.system() on the host is a catastrophic security risk.

12. Cost Kill-Switch Middleware: the router tracks loop depth and estimated spend, stops immediately when it exceeds $0.50, and falls back to a cheaper model. A runaway agent loop is an incident with a bill, possibly burning $500 of API credits before you notice.

13. API-to-Browser Fallback Agent: when the primary REST API returns 404 or times out, the agent seamlessly launches a headless browser to complete the GUI workflow. The real world is messy; 80% of enterprise software has no API, so agents need to adapt to broken environments.

14. Shadow Trajectory Comparator: silently mirror 5% of traffic to the background, run a new agent topology, compare tool-call paths and cost, without affecting users. Non-deterministic agent systems cannot be safely A/B tested directly in production; they need shadow mode.

15. Public Architecture Teardown: publish 3 deep-dive articles explaining swarm topology, state machine design, inter-agent security, and cost per task. Top AI labs hiring agent engineers look for system design judgment, not whether you can import LangChain.

Jonathon Byrdziak posted this image in a reply. Door System v2.7: proximity sensor array, microphone array, hydraulic dampers, redundant hinges. The longer the project list, the more this image looks like self-mockery.

A Few Pieces Added in the Comments

Jatin Garg asked whether recovery from timed-out write operations is the graduation test for tool calling. His reasoning was specific: safe retries require knowing whether the action already happened; merely catching errors is not enough. Suraj replied that if an agent cannot tell whether a write operation has already occurred, retrying is gambling with production data.

Karan raised permissions, which roadmaps often skip: what an agent can touch, for how long, and how to revoke it. Suraj agreed that least privilege should be a core stage; agents need scoped access and revocable permissions by default.

John Rood said the hard part of Stage 4 is not retrieval. Vector recall is the easy half; the real trouble is write rules: what gets retained, with what date, and which record wins when two conflict. Retrieval without priority will surface old decisions and use them as if they were current conclusions.

Unique Adhikari suggested moving evals earlier, right after Stage 3. Once the tool-call loop exists, a few replayable trajectories plus pass/fail checks can determine whether later memory and multi-agent changes are genuinely useful or just look smarter. Suraj's response was more direct: evals should be the foundation of every project; if you cannot measure task success and regressions, you do not dare ship agent updates.

Yashi Srivastava asked what to log first under high concurrency. Suraj said: first add a correlation ID to the complete agent run, then log each tool's input, output, state, and duration; add per-step budgets early, and do not let runaway retries hide inside aggregate metrics.

Alex Puzanov argued that Python asyncio will break down in complex agents and suggested moving to Rust or Go. Suraj replied: first use tracing and load testing to prove where the limit is; rewriting the language will not fix faulty orchestration logic.

Alex Wu did the routing math: 20 routing variables equal 1,048,576 trajectories, and 10,000 evals cover less than 0.01%. Loops in the untested remainder will only show up in tracing after burning through cost. Suraj's advice was: exhaustively check critical routing rules, use property-based testing for edge cases, and ensure safety invariants hold across all trajectories.

6-Month Roadmap

Another one of Suraj's tweets gave 12 stages: Python and async fundamentals, LLM fundamentals, tool calling and structured output, memory and state management, single-agent workflows, multi-agent orchestration, HITL systems, evaluation and quality assurance, observability and tracing, security and guardrails, production deployment, and open source and portfolio.

He wrote in the tweet: 'Most people watch tutorials. Builders ship systems.' Placed in front of these 15 projects, this sentence is clearer than any tutorial list.