Agentic System Design

What makes a system 'agentic' vs a plain LLM call. Autonomy, tools, memory, and the perception–reasoning–action loop.

The four-component reference architecture: model, tools, memory, instructions. How requests flow through each.

Short-term working context vs long-term storage. Episodic, semantic, and procedural memory in agent systems.

How agents take input — text, vision, audio, structured data — and ground it to actions in their environment.

Chain-of-thought, tree-of-thought, plan-then-execute. Where the agent's 'thinking' happens before it acts.

How agents act in the world. Function calls, code execution, API requests, and the safety boundary around each.

Hallucination, long-horizon drift, cost overruns, evaluation difficulty, prompt injection, and the open problems no framework solves for you.

Reason, then act, then observe — the foundational interleaved-thought-and-tool-use pattern that powers most modern agents.

Schema-typed tool calls as the agent's verb. Parallel calls, structured outputs, and the lifecycle of a tool invocation.

Letting an agent review its own output before committing. Self-correction loops, judge-models, and the diminishing-returns curve.

High-level planner + low-level executor. When to decompose, how deep to go, and how to keep sub-plans aligned with the goal.

Sequential, router, swarm, supervisor-worker. The four shapes of multi-agent coordination and what each costs.

When and how to ask for human confirmation, feedback, or override. Designing the handoff so it's neither annoying nor unsafe.

Pre-call validation, post-call filtering, content policies, action allowlists. The defense-in-depth pattern for agent safety.

A multi-agent system for goal-directed conversational recommendations. Multi-agent act planning + user-feedback-aware reflection.

Coding LLMs that autonomously design and refine RL reward functions. Zero-shot generation, evolutionary search, reward reflection.

An agent that solves the 'blank page problem' for LLM-evaluation workflows. Requirement-gathering chat + multi-agent pipeline generation.

A vision-and-text agent that navigates real websites. Multimodal ReAct loop, screenshot grounding, end-to-end task completion.

An LLM-orchestrated approach to multi-object text-to-image generation. Planning, progressive generation, VLM-feedback control.

A personal-assistant design: how to compose an agent that mixes calendar, mail, search, and reminders behind a single conversational surface.

Google's Agent Development Kit. What's in the box: agent primitives, tools, orchestration, evaluation harness, and the workflow it expects.

Wiring an agent to its environment — env vars, tool registration, prompt scaffolding, and the smallest workable hello-world loop.

End-to-end implementation: reward generation, evaluation, selection, reflection, and human feedback — wired together as a closed loop.

Playwright state management, screenshot-and-DOM grounding tools, and a multimodal ReAct loop assembled with ADK primitives.

When to stop. Step budgets, success predicates, stagnation detection, escape-hatch handoffs — the under-loved half of every agent.

A constrained-environment design exercise: turn a sensor + ticketing system into a proactive, intent-aware parking agent.

A safety-critical multi-agent design: triage, diagnosis, second-opinion, and uncertainty handling for a hospital setting.

How to evolve a WebVoyager-style agent over time: experience replay, failure mining, prompt-update loops, eval harness.

An open-ended exercise: pick a real workflow you do daily, decompose it, and design the agent that would automate it.

A 45-minute mock loop for an agent-system-design interview. The prompt, the rubric, and the common follow-up questions.