Home › Tracks › Agentic Systems Engineering
Elite track
Orchestrate fleets of autonomous agents that ship real work.
Engineer reliable multi-agent systems: tool use, planning, memory, sandboxed code execution, and orchestration patterns that move from a single augmented LLM to a coordinated fleet. You build agents an enterprise can put in production, not demos. Bridges directly to classic Operating Systems, Distributed Systems, and Compilers.
Week by week
Every week unlocks the next. Concepts route you to free, world-class material; projects turn that knowledge into something deployed.
Week 1
An agent is an LLM in a loop with tools, retrieval, and memory. Master the atomic building block before composing it: when a deterministic workflow beats an agent, and the failure modes of handing a model autonomy.
Bridges to Operating Systems — processes, scheduling, and the run loopBuilds on: nothing, start here
Week 2
Give a model hands: structured tool schemas, argument validation, error feedback loops, and parallel tool calls. The contract between a model and the outside world is an API design problem.
Bridges to Software Engineering — interface design and API contractsBuilds on: The Augmented LLM as a Building Block
Week 3
Master the Model Context Protocol (MCP) as the universal standard for tool integration. Build stateful JSON-RPC 2.0-based MCP servers using stdio and Streamable HTTP transports, secure them with OAuth 2.1, and design runtime verification safeguards against malicious tool calls.
Bridges to Computer Networks — protocols, client-server architecture, and RPCBuilds on: Tool Use & Function Calling
Week 4
Understand sequence-level planning, search, and tree-based reasoning in LLMs. Implement multi-effort reasoning routing algorithms to dynamically assign queries to 'High' or 'Max' effort thinking configurations (e.g. GLM-5/GPT-5 tiered lineups) to optimize latency, cost, and task accuracy.
Bridges to Artificial Intelligence — search, planning, and state-space reasoningBuilds on: Tool Use & Function Calling
Week 5
Design multi-tiered persistent memory systems for agents. Implement hierarchical memory layers that range from ephemeral CPU-like context registers to local vector indices (Qdrant, Redis) and dynamically curated LLM wikis, allowing surgical context injection without polluting the context window.
Bridges to Operating Systems — memory hierarchy, paging, and cachingBuilds on: Planning, Reasoning & Selectable Thinking-Effort Scaling
Week 6
Build secure executing runtimes for autonomous agents. Utilize Google's stateful Interactions API models with background task execution, provision managed Linux sandboxes, and orchestrate OAuth 2.1-compliant secure tool environments to thwart prompt-injection sandbox escapes.
Bridges to Operating Systems — virtualization, namespaces, and process isolationBuilds on: Agent Memory, Context Engineering & Hierarchical Memory OS
Week 7
You are handed an enterprise mandate: the research division needs a launched product — a system that takes an open-ended technical question, autonomously researches it across many sources, synthesizes a defensible report, and ships the report as a published artifact, with zero human steps in the middle. Build an orchestrator-worker multi-agent system: a lead agent that decomposes the question and spawns specialized worker agents (search, read, synthesize, fact-check), coordinates their results through shared state, and produces a cited deliverable. This is not a notebook demo. The result must be a directly deployable, hyperscalable product: real public hosting, CI/CD on every commit, observability, security hardening, a polished and accessible web UI a non-technical analyst will happily use, and complete go-to-market material — a landing page, a pitch, and a recorded demo. The architecture must absorb concurrent research runs without falling over, and recover from a failed worker. We are not here to babysit the run; ship it as a real product.
Why it matters: Multi-agent research and synthesis systems are being deployed across consulting, finance, and R&D to compress weeks of analyst work into hours. Shipping a coordinated, fault-tolerant agent fleet makes a builder ready for an Agentic Systems Engineer or Applied AI Engineer role, where the bar is production reliability, not a demo.
A publicly hosted product with its own domain or stable URL, plus a public repo: the orchestrator and worker agents, an MCP-based tool layer, a fast accessible web UI for submitting questions and reading results, CI/CD running lint/tests/build on every commit, persisted and inspectable run traces, a marketing landing page, a 10-slide pitch, a recorded demo video, and a README documenting the coordination design, the failure-recovery and scaling strategy, and three example end-to-end runs with their published reports.
Market signal, who wants thisAgentic deep-research is one of the hottest 2026 categories: the AI agent market is projected to grow from $7.84B in 2025 to $52.62B by 2030 (41% CAGR), and a16z reports a portfolio pivot from copilots to autonomous systems, with Sierra, Glean, and Decagon as comparables and YC W26 funding multi-agent orchestration startups such as Tensol and Korso. Consulting, finance, and corporate R&D teams are actively buying systems that compress weeks of analyst work into hours; investors fund this because it sells time back to high-cost knowledge workers.
Week 8
Orchestrate multi-agent systems with modular, reusable markdown-defined skills. Prevent self-refinement blind spots in long-horizon tasks through adversarial collaboration setups (e.g., executor-reviewer loops) to eradicate 'plausible unsupported success' bugs.
Bridges to Distributed Systems — coordination, message passing, and consensusBuilds on: Sandboxed Execution, Stateful APIs & Runtime Security
Week 9
Move beyond manual prompt engineering to compiled, mathematically optimized prompts and markdown skills. Implement automated rollout, reflection, and editing loops (such as SkillOpt) that treat instructions as optimization targets, and leverage DSPy for declarative pipeline compilation.
Bridges to Compilers — program optimization, intermediate representations, and iterative refinement loopsBuilds on: Planning, Reasoning & Selectable Thinking-Effort Scaling
Week 10
Move beyond pure 'vibe coding' to rigorous, verifiable agentic engineering. Design continuous integration pipelines with automated evaluation blockers, sandbox regression test suites, and correctness classifiers for intermediate reasoning steps.
Bridges to Software Engineering — testing, regression suites, and observabilityBuilds on: Multi-Agent Orchestration & Adversarial Collaboration
Week 11
An autonomous agent with tools is an attack surface. Prompt injection, tool poisoning, the lethal trifecta of private data plus untrusted content plus exfiltration, and least-privilege agent design.
Bridges to Information Security — threat modeling and least privilegeBuilds on: Evaluating Agents & Verifiable Software 3.0
Week 12
Build an autonomous coding agent that operates in verifiable domains (e.g., Python/Rust code editing). Implement active test-time scaling (selectable thinking effort), a correctness classifier for intermediate steps, and sandboxed compilation/test loops that serve as the ground-truth reward signal.
A fully functioning coding agent CLI and backend that takes a GitHub issue, spawns a planning tree with selectable thinking effort, executes code in a gVisor/Wasm sandbox, runs a compiler-driven verification loop, and submits a verified PR without human-in-the-loop 'vibe coding'.
What's next
Each track stands alone, so there's no wrong order. If you want a suggestion, this one pairs well next.