Agentic Systems
Learn to design, build and deploy an AI agent you can explain under review.
Architecting Agentic AI Systems with Sunil Mathew
Develop one shared support agent through six stages of practical learning. Build the implementation and examine the permissions, evaluation, recovery and architecture decisions needed to guide its use.
| Programme overview | Details |
|---|---|
| Who this is for | Engineering leaders, architects and staff engineers who need to build, review or guide AI-agent work. |
| Learning outcome | Build and evaluate a shared support-agent learning project through deployment, including control, recovery, evidence and architecture review. |
| Next cohort | Starts Saturday 31 October 2026, 10:00 IST |
| Duration | 6 weeks |
| Format | Online, live cohort learning through implementation, tests and architecture review |
| Cohort | A live cohort of 8, never more than 10. Sessions are not recorded. |
| Certificate | A certificate of completion from Sunil Mathew. It is not accredited by a university or certification body. |
| Hours | 30 live hours; confirm complete setup and pre-session preparation before joining |
| Fee | $1,399 per participant |
| GST | Not charged at the moment. If that changes, we will tell you before you pay. |
| Next step | Request a fit call |
Sunil brings 26 years of engineering experience, past roles at Google, Amazon and Walmart Labs, and current agentic-AI practice. Read his background.
Build a support agent you can examine
The learning project looks up approved policies, checks order status and proposes refunds that require human approval. Returning to the same agent lets you examine how a change in one part affects the rest.
For example, what should happen when a refund request arrives twice, an approval is missing or the retrieved policy is outdated? You test those conditions and inspect the evidence behind retrying, waiting or stopping.
What you'll need
Working Python and access to a model API: the programme uses both. Discuss your current technical capability before joining; the team confirms the full coding prerequisites, setup, supplied materials, accounts and any associated charges.
Six stages of engineering judgment
1. Control tools and actions
Define what the agent may do, its tool contracts, stop conditions and human approval points. Inspect traces and cost to explain what happened.
2. Evaluate changes before release
Build an evaluation set, diagnose failures and compare changes. Use evidence to decide whether a change should pass a release gate.
3. Defend against untrusted input
Test prompt injection and separate model instructions from application permissions. Check whether legitimate requests still work with safeguards in place.
4. Make state and recovery safe
Work through retries, timeouts, durable state and customer isolation. Test how repeated requests can avoid repeated financial actions.
5. Ground answers in the right evidence
Use versioned policy information, retrieval filters and evidence links. Examine whether the answer uses the right source.
6. Choose and review the architecture
Compare a workflow, a single agent and multiple agents. Examine handoffs, shared budgets, release readiness and rollback before explaining the approach you chose.
How the live learning works
- Examine a concept and predict how the agent will behave.
- Implement a change in the learning system.
- Introduce a failure or difficult case deliberately.
- Inspect tests, traces and measured behaviour.
- Explain the result through a quiz or architecture review.
For example, you send the same refund request twice and check that the customer is refunded once.
Each stage connects a practical change to supporting evidence and a decision you can explain. The discussion gives you a way to question a design and revise it when the results challenge your assumptions.
Connect the learning to your responsibilities
- Engineering leaders
develop stronger questions for reviewing AI work and guiding the people building it.
- Architects
examine tools, state, retrieved evidence, permissions and handoffs as parts of one system.
- Staff engineers
practise connecting implementation to evaluation, recovery and operating constraints.
What you'll leave with
- A scoped, runnable support agent and an evaluation suite.
- Failure analysis and evidence from security, recovery and retrieval tests.
- Traces and cost measurements to explain behaviour.
- An architecture decision, evaluation report and rollback plan for the learning system.
Their depth depends on your participation and starting point; the shared project is not a bespoke implementation for your employer.
Learn with Sunil
Sunil has led engineering teams and hired, developed and assessed senior technical professionals. His current work includes agentic-AI products, organisational advice and teaching. The live discussions connect that experience to the implementation and the evidence in front of you.
“Most designs describe the success path in detail and the failure path in one line. The failure path is where the real engineering is.” — Sunil Mathew
The learning scope and your commitment
30 live cohort hours. $1,399 per participant.
The next cohort starts online on Saturday 31 October 2026 at 10:00 IST and runs for six weeks. Before joining, confirm setup and pre-session preparation, full participation, tool costs and payment arrangements with the team.
Deployment takes place in an agreed learning environment. Use in an employer's production systems requires its own engineering, security, privacy, data-access and operating review.
To focus on systems of several agents, compare Design and Build Multi-Agent Systems. For a whole group, discuss enterprise learning.