Design Agentic AI Systems for Engineers
You can build an agent in an afternoon. Designing a system of them is a different job: which agent does what, which model each step needs, what each agent reads and remembers, where a human approves, what happens when a run dies halfway and what it costs each month. In this workshop you answer those questions on paper first, for one real workflow at your company, with a working multi-agent system as the worked example.
Why this matters
Building one agent is an afternoon. Designing a system of them is architecture: which agent does what, on which model, with what context, where a person approves, what happens when a run dies halfway and what it costs each month. Teams that skip the design get a demo that cannot pass review. This workshop is a design review you run on your own workflow, with a working system as the worked example.
Sound familiar?
- Your team can build an agent, and nobody has decided which agent does what or which model it needs.
- The design gets made in production, one incident at a time.
- Nobody can say what the system will cost each month before it ships.
The four hours, block by block
- The system mapWatch it built
Draw the loop, the harness, the roles and the board for one real workflow at your company.
- Roles and modelsBuild it together
Decide which agent does what, and choose a model for each role on quality, latency and cost.
- Context and memoryBuild it together
Design what each agent reads, what it remembers and how its prompt is laid out for the cache.
- Tools and approvalsBuild it together
Scope every tool through an MCP gateway and decide where a human approves.
- Failure and durabilityBuild it together
Plan retries, idempotent writes and what happens when a run dies halfway.
- The token budgetShip your version
Put a cost on every run and a budget on every agent.
- Your architecture reviewShip your version
Present your design and get it reviewed live.
What you will be able to do
- Draw the system first
- Map the loop, the harness, the roles and the hand-offs for one real workflow.
- Choose models and context
- Pick a model per role and design what each agent reads, remembers and caches.
- Plan failure and cost
- Scope every tool, place each approval, plan retries and set a token budget.
The ideas behind it
The agent loop and the harness
The loop is the model choosing tools until it is done. The harness is everything around it: context, tools, limits, retries and logs. Reliability lives in the harness.
Roles and hand-offs
Splitting work into agents with one job each, and deciding exactly what passes between them.
Context design
What each agent reads, what it remembers between runs and what it must never see.
Failure and cost planning
Where a run can stop, how it resumes without repeating a write, and a monthly budget per agent before anything ships.
Where it fits
The parts of a production agent system, in the order the buildcamp builds them. The lit tiles are the ones this workshop builds; the Agentic AI Buildcamp for Engineers builds all of them.
- Roles and modelsOne job per agent, a model chosen for that job, and a token budget.
- OrchestrationA queue agents pick work from, with hand-offs a person can follow.
- Context and memoryRetrieval with sources, memory across sessions, prompts laid out for the cache.
- Tool callingTyped tools that act in GitHub, Linear and Google.
- MCP serversEvery tool behind an MCP gateway, scoped to the role that needs it.
- Durable executionRuns that resume after a crash and never repeat a write.
- Human in the loopA person approves anything that cannot be undone.
- Identity and permissionsEach agent signs in as itself and acts on behalf of a user.
- LLM gatewayRouting, caching and a budget on every model call.
- Traces, evals and costEvery run traced, scored and charged to the agent that made it.
- Multi-tenancyEach team or customer kept apart, in data and in the bill.
- Policy as codeRules checked on every action, not written in a document.
- Signed skillsNew roles built from reviewed, signed skills.
Who it is for
- Software engineers about to build their first agentic system at work
- Tech leads and architects who will review agent designs
- Platform engineers who will run what gets designed
Not for
- New to Python or to calling an LLM API? Start with the recorded lab Build Your First AI Agent in Python.
- Looking for no-code tools? Everything here is code.
Before you come
- For
- Software engineers about to build an agentic system at work, and the tech leads and architects who will review it.
- You need
- You have called an LLM API and built at least one agent or prototype.
- Track
- Agentic AI for engineers who build and run it.
Questions
Is this a coding workshop?
Partly. You watch the core built, build alongside, then design your own workflow. You leave with an architecture document and working code, not only slides.
I already build agents. Is this too basic?
It is aimed at engineers who have built at least one agent and now need to design a system that others will review, run and pay for.
Can I bring a real workflow from work?
Yes, that is the last block of the day. Bring one workflow your team wants agents to handle.
Can my employer pay?
Yes. Maven gives you a receipt your company can expense. To train a whole team, see the private team workshops.
What if I miss part of the day?
Every block is recorded on Maven, so you can catch up on anything you missed.
Do I need to take the free Live Labs first?
No. They help, and each one is listed on this page, but the workshop starts from the beginning of its topic.