Click to Play Episode
An AI agent is a model running tools in a loop toward a goal, and you build one in order: one call, then tools, the loop and evals. Also: frameworks, MCP vs A2A, memory, multi-agent patterns, prompt injection and cost.
A model running tools in a loop toward a goal: model + tools + loop + stop condition (done, turn cap, budget cap, or a human). In a workflow your code decides the next step; in an agent the model does. Coding agents specifically: MLA 22 to MLA 24.
If you can write the steps down, build a workflow. The patterns from Anthropic's Building Effective Agents: prompt chaining, routing, parallelization, orchestrator-workers, evaluator-optimizer. Errors compound: at 95% per step, a 20-step task succeeds about 36% of the time.
0.95 ^ 20 ≈ 0.36
Tool rules: few task-sized tools, namespaced names, readable values over IDs, capped output, descriptions written like a new hire's brief. API first, then page structure, screenshots last.
Simple or learning: write the loop. Operates a computer or codebase: Claude Agent SDK. Light handoffs between agents: OpenAI Agents SDK. Durable runs with human approval: LangGraph. Google or Microsoft stack: ADK or Microsoft Agent Framework. No code: n8n's AI Agent node, Zapier Agents. OpenAI's Agent Builder shuts down November 30, 2026.
MCP connects an agent to tools; A2A connects agents across organizations. Both sit in the Linux Foundation's Agentic AI Foundation. The 2026-07-28 MCP revision is stateless (no handshake or session), moves long jobs into a tasks extension, and deprecates roots, sampling and logging. MCP's context cost: MLA 23.
Working (the context window), episodic (past runs), semantic (facts), procedural (instructions, skills). Manage working memory with compaction, context editing and notes; start the rest as files.
Parallelize independent, read-mostly work; keep one writer. Anthropic's research system beat a single agent by 90% at about 15× chat tokens. Cognition's 2026 update: extra agents contribute intelligence, not actions.
From Demystifying Evals for AI Agents: start with 20–50 tasks from real failures; code graders first, calibrated LLM judges second; grade outcomes, plus trajectory checks for forbidden steps; isolate trials; read transcripts. Tracing tools: MLA 14.
pass@k = P(at least 1 of k succeeds)
pass^k = P(all k succeed) 0.75^3 ≈ 0.42
No session should hold all three of the lethal trifecta: private data, untrusted content, external communication or state changes. When a task needs all three, a human approves side effects. Design patterns: plan-then-execute, dual LLM and four more in this paper.
Route easy steps to a small model → cache a stable prompt prefix → cap context and tool output → stop early. Hosting and batch pricing: MLA 14.
The full course on this topic is Gnothi's Agentic AI Course, next to Claude Code, at ocdevel.com/courses.
More in the resources. Next: MLA 29, on OpenClaw and personal agents.
AI wrote the script, and you're hearing an AI clone of my voice. Gnothi, a tool I built, did the research, the writing, and the narration, so the whole episode is a demo of what it can do.
This episode is about how an AI agent is built. It covers what an agent is, how to build one starting from a single model call, whether to use a framework, how tools, protocols and memory work, when several agents beat one, how to measure whether yours works, and how to keep it from being turned against you by the text it reads. The next episode applies all of that to a personal agent that runs all day on your own accounts. If you came for coding agents specifically, episodes twenty-two through twenty-four cover those products and how to work with them. This one is the architecture underneath them.
Start with the definition, because the word has been stretched over everything from a chatbot with a search button to a fleet of processes rewriting a codebase overnight. The definition that has settled among practitioners is Simon Willison's, from September twenty twenty-five: an agent runs tools in a loop to achieve a goal. That gives you four parts. There's a model, a set of tools it can call, a loop that feeds each tool's result back to the model, and a stop condition. The model reads the goal, picks an action, your code runs that action, the result goes back into the model's context, and the model picks the next action. It stops when the model decides it's finished, or when something you set stops it: a turn limit, a spending cap, or a human saying no.
The useful line to draw is who owns the control flow. Anthropic's essay Building Effective Agents, from December twenty twenty-four, still has the cleanest version. A workflow is a system where models and tools are orchestrated through code paths you wrote in advance. An agent is a system where the model directs its own process and decides which tools to use. In a workflow, your code decides what happens next. In an agent, the model does. Plain chat sits at one end of that spectrum, and a chat assistant with tools sits one step along, with the human still choosing each move. Most products sold as agents land somewhere in the middle, and knowing where tells you more than the marketing does.
So that's the definition. Next, when you want an agent at all.
The same Anthropic essay names the workflow patterns that cover most systems, and each is cheaper and more predictable than an agent. Prompt chaining runs one call after another, with a check in code between steps. Routing classifies the input first and sends it to a specialized prompt or a smaller model. Parallelization splits a job into independent pieces, or runs the same job several times and takes a vote. Two more sit closer to agents: orchestrator-workers, where a model breaks a task into pieces at run time and hands them out, and evaluator-optimizer, where one call drafts and another critiques until the draft passes.
The decision rule follows from that. If you can write the steps down in advance, build a workflow. Microsoft's Agent Framework documentation puts it more bluntly: if you can write a function to handle the task, do that instead of using an AI agent. Use an agent when the path depends on what it finds along the way, so you can't list the steps ahead of time. Debugging is like that, and so is open-ended research, or a support ticket where you don't know the problem until you've looked at the account.
The reason to prefer the workflow is that errors in a loop compound. If each step is right ninety-five percent of the time, a twenty-step task finishes correctly a bit over a third of the time, because point nine five to the twentieth power is about point three six. Every step you fix in code is a step the model can't get wrong. Much of agent engineering comes down to fighting that compounding: better models per step, tools that report errors clearly, a verifier that catches a bad step before the next one builds on it, and evaluations that measure the whole run.
That's when to build one. Now, how.
The procedure that holds up is to start smaller than feels reasonable and add one layer at a time. Take an illustrative example: a small software company wants an agent that answers billing emails, looks up the customer's account, and can issue a refund up to fifty dollars. Begin with one model call. Write twenty or so realistic emails, with the answer you'd want for each, and see how far a single well-written prompt gets with the account details pasted in by hand. If one call does the job, stop there: that's a feature, and it's cheaper to run and easier to test than any agent.
When one call isn't enough, add tools. A tool is a name, a plain-language description, and a schema for its arguments. For the billing agent, that might be a tool to look up a customer by email address, one to list their invoices, one to issue a refund, and one to send the reply. When the model decides a tool is the right next move, it returns a structured request to call it, with arguments, instead of prose. Your code runs the function and hands back the result. The model never executes anything itself. It asks, your code acts, and your code can refuse, which is where every permission check lives.
Then add the loop. Call the model; if it asked for a tool, run the tool, append the result to the conversation, and call the model again; when it answers without asking for a tool, you're done. Put a hard cap on the number of turns and on the money spent, because a confused agent will happily loop. That loop is the core of an agent, a few dozen lines in most languages, and writing it once yourself is the fastest way to understand what every framework is doing for you. You can build it at home on a laptop with an API key. Running the model locally instead is a hosting question, and episode fourteen covers it.
Planning fits into that loop in two places. The original pattern, from the twenty twenty-two ReAct paper, interleaves a written thought before each action with the observation after it. Current models do much of that reasoning internally: Anthropic's models now decide for themselves how much to think before each step, steered by an effort setting you choose. For longer tasks, the harness adds an explicit plan, a to-do list the agent writes at the start and updates as it goes. Microsoft's Agent Framework, for one, builds planning and to-do tracking into its ready-made harness. An explicit plan pays off three ways. A person can review it before any money is spent, the agent can re-read it after older context has been summarized away, and fixing the actions up front is also a defense against injected instructions, which comes up later. Have the agent replan when an observation contradicts the plan, and not on every turn.
Last, before adding any features, add a way to check the work and a set of test cases you rerun after every change. Both come back later in this episode. The order matters: one call, then tools, then the loop, then evaluation. Most failed agent projects skip straight to the loop with fifteen tools, and then can't tell which part is failing.
So that's the build order. Now the part that decides most of an agent's quality: its tools.
Anthropic's engineering post on writing tools for agents, from September twenty twenty-five, gives the practical rules. Build fewer, larger tools that match a task, rather than one wrapper per API endpoint. Their example is a single schedule-event tool that finds availability and books the meeting, in place of separate tools to list users, list events and create an event. Name tools by service and resource so the model can tell them apart. Return readable names instead of opaque IDs, which in their tests cut hallucinated lookups. Cap how much a tool returns, with paging and filters, because every byte lands in the context window. Claude Code caps a tool's response at twenty-five thousand tokens by default. And write each description the way you'd brief a new hire, because the description is a prompt.
Two more rules from Anthropic's writing. Design tools so mistakes are hard to make. When their coding agent kept getting relative file paths wrong, they changed the tool to require absolute paths, and the errors stopped. And apply the overlap test from their post on context engineering: if a human engineer can't say for sure which of two tools fits a situation, the model can't either. When two tools overlap, merge them or rewrite their descriptions until the choice is obvious.
The deeper principle is verifiable feedback. A large part of why coding agents became useful before other kinds is that code comes with checks. When a coding agent runs the tests, it gets a clear observation: pass, or fail with an error pointing at a line. That signal feeds the next step, so a bad step gets caught inside the loop that made it. Compare a browser agent booking a hotel, whose only feedback is a changed page and no way to know it picked the right room. So when you design an agent for any domain, find the verifier first. A schema validator, a reconciliation against the ledger, a diff against a known good output, a test of the refund total: wire that in as a tool the agent must call before it reports success.
Where no API exists, there's computer use: the model looks at screenshots and sends mouse and keyboard actions. Anthropic's computer use toolset is now stable, with seventeen actions including a zoom for reading small text, and it automatically scans screenshots for injected instructions. It's still the slowest, most expensive and least verifiable way to do anything, because the observation is a picture. Take the options in order: an API first, then a tool that reads the page's structure, such as a browser tool or an accessibility tree, and screenshots last.
Next, the protocols that connect those tools to an agent.
The Model Context Protocol, MCP, is the standard way to expose tools and data to any agent. You write a server once, and any compatible client can connect to it without custom glue code: Claude, the major coding agents, and the agent kits from Anthropic, OpenAI and Microsoft all speak it. Anthropic published it in late twenty twenty-four. Since December twenty twenty-five it has lived in the Agentic AI Foundation, a Linux Foundation project that also holds Block's goose agent and the AGENTS.md instruction-file format, and which passed three hundred member organizations in October. MCP's technical seats belong to individuals, with no company holding a reserved seat.
The current specification is the July twenty-eighth, twenty twenty-six revision, and its headline change is that MCP went stateless. The opening handshake and the protocol session are gone. Every request now carries its protocol version and the client's capabilities, so any server instance behind a load balancer can answer it, and a server that needs state across calls hands out an explicit handle that comes back as an ordinary tool argument. That makes remote MCP servers much easier to run on serverless platforms. Long-running work moved into an official tasks extension: a tool returns a handle at once, and the client polls it or sends more input while it runs. Requests a server used to start on its own, such as asking the user a question mid-operation, now go the other way: the server answers that it needs input, and the client retries with the answer.
A few smaller changes matter for builders. Three features are deprecated, with at least twelve months before removal: roots, sampling and logging. The suggested replacements are to pass directories as tool parameters, call your model provider's API directly, and log through OpenTelemetry. Servers should now list their tools in a fixed order, so that the client's prompt cache keeps hitting from one request to the next. If you maintain a server, this revision means an SDK upgrade. If you only connect to servers, little changes, except that more of them will be hosted remotely. What every connected server costs in context, and how tool search trims that, is a configuration question that episode twenty-three covers.
The second protocol is A2A, short for agent to agent. MCP connects an agent to tools, and A2A connects an agent to other agents: each agent publishes a card describing what it can do, and another agent sends it a task and gets back messages and finished artifacts. Google created it. Version one point oh, the first stable specification, shipped in March twenty twenty-six with signed agent cards and version negotiation, and in August A2A moved into the same Agentic AI Foundation as MCP. More than a hundred and fifty organizations back it, and Google Cloud, Microsoft's Azure AI Foundry and Amazon Bedrock AgentCore all support it. The project's own site sums up the relationship: MCP for tools, A2A for agents, use both.
The decision rule is about boundaries. Inside your own system, one agent calling another is a function call or a subagent, and a protocol adds nothing. A2A matters when an agent crosses an organization or vendor boundary: your procurement agent negotiating with a supplier's sales agent, or an assistant on a phone handing a task to an app's agent. The early production deployments the foundation lists are that kind, between companies and platforms. For a single team building one product, MCP is the protocol you'll use this year, and A2A is the one to adopt when a partner asks for it.
That's the plumbing. Now, memory.
An agent's memory is easier to design when you split it into four kinds and ask where each one lives. Working memory is the context window, the only thing the model sees on a turn. Episodic memory is what happened in earlier runs: past conversations and their outcomes. Semantic memory is facts, like this customer prefers email, or this account is on the annual plan. Procedural memory is how to do things: instructions, playbooks and skills. Working memory lives in the prompt. The other three live outside the model, in files, a database or a search index, and come into context only when something pulls them in.
Most of the engineering goes into working memory, because the context window is finite and it degrades as it fills. Anthropic calls this context rot: recall of any one detail drops as the token count grows. Their stated goal is the smallest possible set of high-signal tokens that gets the job done. Three mechanisms do that, and Anthropic and OpenAI both offer versions of them. Compaction summarizes older turns when the conversation gets long and continues from the summary. Context editing clears stale tool results, such as a file read twenty turns ago, while keeping recent ones. And notes have the agent write durable facts to storage before compaction loses them.
Anthropic's memory tool shows how plain the note-taking side can be. It's a directory of files. The model asks to view, create, edit, rename or delete a file, and your code carries out each request against storage you control. When the tool is on, the system prompt tells the model to check its memory directory before doing anything else and to assume its context could be reset at any moment. The documentation's security section warns about one thing above all: path traversal, a request that climbs out of the memory directory to read other files. Memory written from untrusted input is also a way for an injected instruction to survive into future runs, so treat what goes into memory with the same suspicion as what comes out of it.
The practical advice is to start with files and the built-in context mechanisms. Reach for a vector store or a knowledge graph only when you can name a query that files and keyword search can't answer, such as finding every past conversation where a customer complained about the same thing in different words. Third-party memory layers such as Mem zero and Letta exist for that, and they now compete with first-party features from every major lab. Procedural memory is usually the cheapest win: one well-written instruction file or skill, loaded only when the task needs it, beats a pile of examples in every prompt.
Next question: when to use more than one agent.
Two essays set the terms of this debate, published a day apart in June twenty twenty-five. Anthropic described its research system, where a lead agent on Claude Opus four sent parallel subagents on Claude Sonnet four to search, then combined their findings. On Anthropic's internal research evaluation it beat a single Opus four agent by ninety percent. The cost was tokens: agents use about four times the tokens of a chat, and their multi-agent system used about fifteen times. On a web-browsing benchmark, token usage alone explained eighty percent of the difference in performance. The same post said the approach fits poorly when agents must share context or depend on each other, which includes most coding.
The other essay was Cognition's Don't Build Multi-Agents. Cognition makes Devin, an autonomous coding agent, and its argument was that every action carries implicit decisions, so two agents working on the same thing without seeing each other's full history will make conflicting choices. In April twenty twenty-six Cognition published an update on what had since worked in production. The common rule: writes stay single-threaded, and extra agents contribute intelligence rather than actions. The patterns that work for them start with a reviewer agent that checks the writer's pull requests without sharing its context, and catches on average two bugs per pull request, more than half of them severe. Episode twenty-four covers that kind of review loop for your own code. Another is a model consulting a stronger one on hard questions, which worked only when both models were strong. The third is a manager agent splitting a large task across child agents. Swarms of parallel writers, they said, still don't work.
Those two accounts agree once you look at task shape. Parallelize work that is independent and read-mostly: searching, researching, reviewing many files, running many checks. Each subagent burns its own context on the noise and returns a condensed summary, often one or two thousand tokens, to the lead. Keep work that changes shared state in one thread with one writer. And budget for it: a fifteen-fold token bill is worth paying for a research report that matters and wasteful for a refund. Google's guide to multi-agent patterns, from December twenty twenty-five, gives names to the common structures: a sequential pipeline, a coordinator that dispatches to specialists, parallel fan-out and gather, generator and critic, and human-in-the-loop. Those names are handy for design reviews, but each one still has to pass the single-writer test.
With the architecture settled, what do you build it with?
Both major labs gave the same first advice: start without a framework. Anthropic's essay recommends calling the model API directly, because many patterns take a few lines of code and frameworks can hide the prompts you need to see when debugging. Most current frameworks reflect that view: they're thin harnesses around the loop you just heard described, and their value is a loop already run hard in production, with tracing, retries and state handled.
The Claude Agent SDK, for Python and TypeScript, is Claude Code's loop as a library. You get its built-in tools for files, shell commands and web search, plus hooks, subagents, MCP, permission controls, sessions that resume, and skills. It's the shortest path to an agent that works on a machine, and the cost is that you adopt Anthropic's opinions about the loop and its models. If you'd rather Anthropic host the loop and the sandbox, Claude Managed Agents, still in beta, runs sessions in Anthropic's cloud or in your own. The OpenAI Agents SDK, also Python and TypeScript, centers on small agents that hand off to one another, with guardrails, sessions, tracing and sandboxed workspaces. It uses OpenAI's Responses API by default and reaches other providers through adapters. OpenAI is retiring its visual Agent Builder on November thirtieth, twenty twenty-six, and points people to the SDK or to agents built inside ChatGPT.
Google's Agent Development Kit, ADK, is now on version two, which added graph workflows that mix fixed code paths with model decisions. It runs in five languages, speaks A2A natively, and works with models beyond Gemini. Google also announced an Antigravity SDK in May, giving programmatic access to the agent harness behind its own products. LangGraph is the choice when state matters most: it describes itself as a runtime for long-running, stateful agents, with durable execution that survives a crash and pauses that wait for a human to approve. Microsoft's Agent Framework is the direct successor to AutoGen and Semantic Kernel, for teams in Microsoft's stack, in dot NET, Python or Go. CrewAI, Pydantic AI for typed Python agents, and Vercel's AI SDK for TypeScript apps round out the actively maintained field.
The decision rule. To learn, or for a simple agent, write the loop yourself. For an agent that operates a computer or a codebase, use the Claude Agent SDK. For several light agents passing work around, the OpenAI Agents SDK fits. If you need durable, resumable runs with human approval steps, use LangGraph, and inside Google Cloud or Microsoft shops, use that vendor's kit. If you don't write code, no-code builders run the same loop inside a drawn workflow. n eight n's AI Agent node picks its own tools within a flow you designed, Zapier Agents reach its thousands of app integrations, and ChatGPT's workspace agents do it inside a team's ChatGPT account. For many business automations, an agent step inside a fixed workflow is the right amount of autonomy.
Once it's built, you have to measure whether it works.
An agent that works in the demo and fails in production is the default outcome, because what you're grading is a whole trajectory of decisions, and any one of them can go wrong. Anthropic's January twenty twenty-six post, Demystifying Evals for AI Agents, gives the most practical procedure, and it starts small: twenty to fifty tasks drawn from real failures is enough to begin. A good task is one where two domain experts would independently reach the same pass or fail verdict, and each task needs a reference solution proving it can be passed. Include cases where the agent should act and cases where it should refuse. For the billing agent, that means a valid refund, a refund over the limit, and an email asking it to refund someone else's account.
Grade with the cheapest grader that works. Code checks come first: did the refund total match, did the record change, did the reply go to the right address. They're fast, objective and reproducible. Use a model as a judge only where judgment is needed, such as the tone of a reply. Calibrate that judge against a person's verdicts on a sample, grade each dimension with a separate judge call, and give the judge an "unknown" option so it doesn't invent a verdict. Humans grade the samples that calibrate the judge, and from then on only occasionally.
Grade the outcome, not the path, with one exception. Checking that the agent took an exact sequence of steps makes tests brittle, since a good agent often finds a route you didn't predict. The exception is a step that must never happen, or must always happen: the refund tool called without a lookup first, or an over-limit refund without human approval. Those trajectory checks are worth writing, because they're your safety rules turned into tests.
Then measure reliability as well as capability. Pass at k is the chance that at least one of k attempts succeeds, which suits tasks where one success is enough. Pass to the power k is the chance that all k attempts succeed, which is what a customer-facing agent needs. The gap is large: an agent that passes seventy-five percent of the time passes three runs in a row only about forty-two percent of the time. The tau-bench customer-service benchmark introduced that second metric in twenty twenty-four. Princeton's Holistic Agent Leaderboard now tracks reliability across many models and finds the gap substantial for all of them, with reliability improving more slowly than accuracy.
A few habits keep the scores meaningful. Split your suite in two. Capability evaluations start with a low pass rate and give you a hill to climb. Regression evaluations should pass nearly every time, and they catch backsliding when you change a prompt, a tool or the model. Start every trial from a clean environment: Anthropic reports a case where Claude gained an unfair advantage by reading the git history left by earlier trials. If a task scores near zero across many runs, suspect the task or the grader before the agent. And read the transcripts. A score tells you something broke, and the trace of every model call, tool call and result tells you what. A tracing tool such as Langfuse records those traces for you, and episode fourteen compares the tracing tools.
So that's evaluation. Next, the design constraint that shapes every agent that reads outside content.
Prompt injection is text inside the agent's input that the model follows as if it were your instruction. It might be a line in a customer email, hidden text on a web page, or a comment in a document. The model has no reliable way to tell your instructions from instructions inside the data it reads, because both arrive as tokens in the same context. OpenAI said in December twenty twenty-five that prompt injection, like scams and social engineering, is unlikely to ever be fully solved. So treat it as a constraint you design around, the way you'd design a web app around untrusted user input.
Simon Willison's lethal trifecta names the dangerous combination: access to private data, exposure to untrusted content, and a way to communicate externally. An agent with all three can be tricked into sending your data to an attacker. Meta's Agents Rule of Two, from October twenty twenty-five, turns that into a design rule. In any one session, an agent should have at most two of these three: processing untrusted input, accessing sensitive systems or private data, and changing state or communicating externally. If a task needs all three, it shouldn't run unattended, and a human approves the consequential steps. Filters that detect injected text help, but Willison's point stands: a filter that catches ninety-five percent of attacks is a failing grade in security.
Run the billing agent through that rule and the problem is plain. It reads customer emails, which are untrusted. It sees account and payment data, which is private. And it can issue refunds and send replies, which change state and communicate. That's all three, so something has to give. The cap on refunds limits the damage. Sending every reply to the address on the account, never to an address found in the email, closes the obvious leak. Anything outside the rules, such as a refund over the limit or a change of email address, waits for a person.
Researchers have published architectural patterns that make an agent resistant to injection by design, without trusting the model to notice. A June twenty twenty-five paper describes six. Two carry the idea. In plan-then-execute, the agent fixes its sequence of actions before it reads any untrusted content, so a malicious email can change the reply's wording but can't add a new action. In the dual-model pattern, a privileged model that can use tools never reads untrusted text, and a quarantined model with no tools reads it and passes back only constrained results. The CaMeL system, from a March twenty twenty-five paper, pushed this further, with a policy engine outside the model deciding which data may flow into which action. It completed seventy-seven percent of the tasks in a standard agent security benchmark with provable protection, against eighty-four percent with no defense at all. That trade, a few points of capability for a guarantee, is the shape of the choice.
How a coding agent's permissions and sandbox put this into practice is covered in episodes twenty-three and twenty-four, and the next episode applies it to an agent that reads your inbox.
Last topic, cost and latency.
An agent costs more than a chat because the loop resends the growing conversation on every turn, which is where the four-fold multiple from Anthropic's research post comes from. There are four levers, in rough order of payoff. The first is routing. Send classification, extraction and routing steps to a small model, and save the frontier model for the hard decisions. In Anthropic's current lineup, Sonnet costs half as much as Opus, and the smallest Haiku tier costs a small fraction of either. The second is prompt caching: keep the system prompt and tool definitions identical and first in every request, so the provider serves them from cache. Anthropic bills cached tokens at a tenth of the normal input price or less. That's why the new MCP revision asks servers to list tools in a fixed order.
The third lever is context discipline: fewer tools, capped tool output, compaction and subagents that return summaries. Every token you keep out of the window is paid for on every later turn, so savings compound the same way errors do. The fourth is stopping early: a turn cap, a budget cap per task, and a verifier that ends the run the moment the work passes. For latency, run independent tool calls in parallel and stream partial results to the user. Batch processing, at half price on Anthropic's API, suits work nobody waits for, such as a nightly run, and episode fourteen covers that and the rest of the hosting decision.
To recap. An agent is a model running tools in a loop toward a goal, and you build one in order: one call, then tools, then the loop, then evaluations. Prefer a workflow wherever you can write the steps down. Tools decide quality, and a verifier the agent must pass is the most valuable one. MCP connects agents to tools and went stateless this year, and A2A connects agents across organizations. Memory is mostly files plus disciplined context. Add agents for parallel reading, keep one writer, and budget for the tokens. Evaluate reliability on a small suite drawn from real failures. And design so that no unattended session holds private data, untrusted input and the power to act all at once.
This episode was the overview. The full course on this topic is the Agentic AI Course, on Gnothi, and it teaches by running a business. It follows a solo founder who hands real work to Claude. It starts with a Claude Project that turns customer research into an opportunity brief, then uses Claude Code to build the first working piece of the offer. From there, agents research prospects and keep the customer records, carry the customer from payment through onboarding and delivery, and close the books. Each lesson shows the request, an output you can inspect and the evidence that it worked. The course then hands complete recurring workflows to unattended agents, with permissions, budget limits, retries and protection against duplicate actions. It builds toward a representative week the business runs without its owner, closed by a short briefing on what ran, what it cost and what needs a decision. Claude Code is listed beside it, a course that goes from a first code change to a product it keeps improving while you're away. Both are at O C devel dot com slash courses. That's O C D E V E L dot com, slash courses.
Next, episode twenty-nine takes one always-on personal agent apart, OpenClaw: what people use it for, the security incidents of the past year, and the setup that makes it safe enough to let near your email.