Seen from above: a beaver swims across a misty pond toward its dam and lodge, with a branch in its mouth.

An agent is AI with its own computer.

Chat to agent is the hardest conceptual jump in the curriculum, and it is rarely explained simply. This part covers what an agent is, the terminal without fear, plan mode, MCP, context hygiene, and the 15/45/15 method.

A beaver builds its own dam and lodge, one branch at a time.

Tanush Jagdish · Part 2 of 6 · 15 min read

#1What an agent is

In Part 1 you learned where chat stops. You hit three walls: every new chat means re-explaining your project, the answer is not the deliverable (you still build the PowerPoint, the Excel model, or the document by hand), and a nagging sense remains that far more is possible. This part is the way through, and once the idea is on paper, it is simpler than it looks.

An agent is an LLM plus a loop plus tools. Its tools are basic: read files, write files, run code, and search the web. It uses them over and over, checking the results and trying again, until the job is done.

What really is an agent?LLM + loop + tools
LLMthe model
loop
…using tools, over and over
  • Read files
    pull context in
  • Write files
    produce output
  • Run code
    act in the world
  • Search
    reach the web

An agent = an LLM + a loop + tools.Back and forth, until it gets the job done.

What an agent is: an LLM, a loop, and tools (read and write files, run code, search).

Most confusion is about where the line sits, so build it up in three tiers. A chatbot is text in, text out, with no tools: ChatGPT as it first launched. A workflow is what many companies already call an AI agent: an email drafter wired to one tool and one knowledge base, with a system prompt that says “you are an email agent; draft good emails from this data source.” It is close, but it does one job on rails, so it is not really an agent. An agent is an LLM with tools and, to some extent, a computer of its own, where it keeps using those tools until it reaches a goal. Focus on the phrase “a computer of its own.” A basic chat window or a custom chatbot has no computer to operate, so it cannot work this way. On the command line, Claude Code and Codex use your laptop’s terminal as their operating environment. On the web or on a phone, agents such as Cowork and ChatGPT Work use a computer in the vendor’s cloud. Tool calls and code execution are what make something an agent; skills, the subject of Part 3, specialize it.

Why does a computer make it so powerful? Because code is text. An LLM only produces text; it is a next-token predictor, which is the familiar criticism, and it is true. But code is text too. An LLM writes code, your computer runs it, and that code opens the folder, reads what is needed, and returns the result. Current models are strong programmers, so a prompt becomes code that operates your computer from the terminal. Every deliverable you make is software sitting on top of words and numbers: slides, spreadsheets, and memos are all files that code can produce. If the agent can write code and has a computer to run it on, it can make those files directly. It does not tell you how to make them; it makes them.

So do not get hung up on the word agent. Online, the label gets applied to almost anything, and in practice it is a matter of degree. A skill that fires and runs code is a more capable agent than much of what gets called an agent online. What matters is which harness and which model you use.

#2Model vs harness: the cleanest way to see the jump

If you remember one frame from this part, make it this one. Two agents can run exactly the same model; what differs is the harness, the application that wraps the model and lets it act in the world.

The cleanest frameModel + Harness = Agent
The intelligence

Model

The brain. The exact same model under the hood, whether you chat or operate.

OpusGPT
+
The arms and legs

Harness

What you plug the model into so it can do stuff in the world.

Claude CodeCodex
=
The resultAgent

It’s the same intelligence either way. The jump from chat to agent isn’t a smarter model. It’s the harness that gives that model arms and legs.

Model (the intelligence, such as Opus or GPT) plus harness (the arms and legs, such as Claude Code or Codex) equals an agent.

Labs such as OpenAI and Anthropic make the models. For a model to do anything, it has to be wrapped in an application: a harness. Some harnesses are essentially chat apps. Claude Code from Anthropic and Codex from OpenAI are full agents. As of September 2026, both vendors also put full agents inside their desktop apps: Cowork in the Claude app, and Work and Codex in the ChatGPT app. The clearest analogy: a chat app is like a contractor working remotely who cannot access your files, so you send everything over and they email results back. An agent is the same contractor sitting at your desk, working inside your computer. Chat modes are deliberately small, safe boxes: the less they can do, the fewer mistakes they can make. Claude Code, by contrast, can edit the files in your project folder directly.

Harnesses also improve underneath you. Claude Code ships updates constantly; when its developers find a better context-management technique, it goes into the harness, and a problem you used to manage by hand disappears. One practical consequence is that the model is swappable. Frontier models from the major labs perform at a similar level and can be switched. Choose your harness, and treat the model as a setting.

People spend a lot of energy choosing between Claude Code, Codex, Cowork, and Cursor, and they do not need to. Claude Code and Codex are comparable: Anthropic’s and OpenAI’s versions of the same idea. Cowork brings the Claude Code agent into Anthropic’s desktop app and, since July 2026, into its web and phone apps. I use all of them, but only because clients use all of them and I need to keep up. Pick one and start. A few notes from the field:

  • In our sessions in spring 2026, Cursor was the usual fallback for consultants, because Claude Code and Codex were often blocked at large firms. It works: everything in this curriculum can be done in Cursor’s agent chat.
  • Split conceptual work from execution. Use Claude Code or Codex for the problem-solving, and a specialized harness, such as Claude for Excel, to write the formulas. Different harnesses suit different sub-tasks.
  • In our sessions in spring 2026, Cowork sometimes favored its own built-in skills over a learner’s own, so we moved serious skill work to Claude Code. To migrate, tell Claude Code you have been using Cowork and ask it to help you move over; in those sessions it usually did so in one pass.

One thing we do not teach: N8N and Zapier. Cars offer a useful comparison. Early automobiles were horseless carriages, an engine bolted onto a carriage design, and they worked poorly until the car was redesigned around the engine. N8N and Zapier are built for an older style of automation, where thing A finishes and signals thing B to start. An agent does not run a fixed pipe; it loops, decides, and acts. It is a different machine, not a faster carriage.

This is also where the change starts to feel real, which can be unsettling as well as exciting. One consultant put the tension plainly after building a set of his own agents:

“I am personally five times more productive, but the senior partners still want PowerPoint decks and still want 60-minute problem-solvings to rehash things. This time is a special time for the way that we work.”

a consultant at a global strategy firm

#3The terminal, without fear

For most people, the first real obstacle is a black screen with a blinking cursor. A little history helps. In the 1980s, Apple popularized the graphical interface, borrowing ideas from Xerox. Before that, you opened a folder by typing a command: cd Olitolabs, short for “change directory.” Everything a computer does still happens through code. A graphical interface is a friendly layer on top, and the terminal is the layer underneath that was always there. Command-line agents such as Claude Code and Codex are chat placed on the terminal. When you say hello to Claude, the message still goes to the LLM, but now the LLM can also run commands in your terminal, and because it writes code well, it can do much of what you can do on a computer. Agent modes in the desktop apps put a graphical interface over the same loop.

Try it on your first run. Type “Look in my Downloads folder. What is in it?” Watch it run ls Downloads, read the result, and decide what to do next. That is the loop, live: like a person opening a folder, reading, moving to another folder, and reporting back. If you do not come from a technical background, the terminal can feel intimidating, and that anxiety is normal.

“I’m not an engineer. When I see a line of code I’m getting dizzy. I’m afraid that I will make a mess and not be able to correct it later.”

a management consultant learning to operate an agent
Before we start~15 min, async
  1. 1

    Install your CLI agent

    Claude Code or Codex: your terminal-native AI.

  2. 2

    Open the terminal, run one command

    Type claude or codex, then hit enter.

  3. 3

    Navigate to a folder

    cd to your project, ls to see files.

  4. 4

    Ask one question

    “Read this file and summarize it.”

Choose your tool
ToolTerminal (CLI)Desktop app
Claude CodeMac, Windows, LinuxMac + Windows
CodexMac, Windows, LinuxMac + Windows

We teach the terminal. It’s the most direct way to see what the agent is doing. You can also start in a desktop app’s agent mode.

Common blockers + fixes
Windows
Install Git for Windows first; PowerShell works natively for Claude Code.
Mac
Run xcode-select --install for Git + build tools.
Codex users
Use the standalone installer. Only the npm install needs Node.js.
Corporate laptop
Use your personal machine. IT blocks won’t resolve in time.

Most people spend 15 to 25 minutes fighting setup friction. You are not behind; that’s just the toll booth. Get past it and ask your first question.

Before you start in the terminal: install a command-line agent, open the terminal, run your first command, move around with cd and ls, and ask one question. Includes a tool-choice table and fixes for common blockers.

You can start in the agent mode of a desktop app, such as Cowork or ChatGPT Work, or in Cursor. Do not let the interface stop you from starting. We teach the terminal because it is the most direct way to see what the agent is doing, and it gives you the most control. Two notes on terminal setup. First, most people spend 15 to 25 minutes fighting setup friction (developer tools on a Mac, Git on Windows, Node for some installs). You are not behind; that is the cost of entry. Second, if you are on a locked-down corporate laptop, use a personal machine, because IT approvals rarely arrive in time. Keep two short lists by your keyboard: the terminal essentials (cd, ls, pwd, clear, cd .., cd ~) and the harness commands (/new, /clear, /resume, /compact, plus Shift+Tab for plan mode, Esc twice to edit a previous turn, @ to search for files, and the context percentage). If you get lost, type cd ~, then clear, then /new. You are never more than three commands from a clean slate.

Permissions are a dial, not a switch. When the agent first asks whether it can run a command, you are watching the safety system work, which is a good thing. Each agent is scoped to a workspace: the project folder you open determines where it can operate, and it has to ask before acting outside it. My default advice is to open your whole working folder as the project. On manual approval, you approve each command, but by the fiftieth approval you are no longer reading them, and it is time to turn the dial. Settings run from manual approval, to auto mode, where a classifier approves routine actions and blocks risky ones, to skipping permission checks entirely. As of September 2026, Claude Code starts a new session in auto mode by default, so you may begin in the middle of the dial. Turn the dial up as your trust grows, or down to manual approval when you want to check each step. If you want one guardrail while you move fast, learn the few commands that reach beyond your folder (rm deletes files; git push publishes them), and add a line to your CLAUDE.md telling the agent to ask before running them. You do not have to watch everything, only the few actions that matter. Desktop apps now have their own version of this dial, and the terminal still gives you the most control over it. And when the agent stalls or gets lazy, remember that it behaves like a person with access to your computer: if you push it, it will usually do the work.

#4Plan mode: propose first, act second

One habit matters most in this part: before the agent does anything big, make it tell you what it is going to do. In Claude Code, Shift+Tab cycles through the permission modes, including plan mode. In plan mode, instead of doing the work, the agent writes a detailed plan. You review it and say what to change. Correcting it before it acts is one of the best ways to prevent misalignment. You can state the discipline in one sentence: if you tell it how to do something, it will simply go and do it, so ask for a plan first. Get into a rhythm: ask for the plan, read it, ask what it needs from you while it executes, then let it go. You catch a misunderstanding before it costs you twenty minutes of wrong work.

As you go deeper, plan mode grows into something more durable: contract-based development, a longer process of agreeing with the AI on what you want before it executes. Your plan becomes a contract between you and Claude. Whatever it builds, it reports back against the contract: where things stand, what is done, and what it did differently. A fixed contract matters because of how these models break. As an agent works, it fills more of its context window, and as the window fills, performance degrades and the agent gets confused. A fixed document lets you refresh the context: a new agent that knows nothing reads the contract, compares it with what was built, and sees what remains and whether anything has drifted. Contracts come in two kinds, and the distinction leads into the next part: a contract on the workflow is a skill, and a contract on the final state is a plan. You will build both.

At the far end is goal mode, which needs care. Some harnesses let you point the agent at a contract with a command such as /goal, and it keeps working until the objective is met. That is powerful, but it will not stop until it is done, so use it only for outcomes you are certain you want. Underneath all of these features is the same loop every coding agent runs.

The loop underneathEvery coding agent runs this
  1. 01

    Gather

    pull in the context: files, docs, the task

  2. 02

    Plan

    decide the approach before touching anything

  3. 03

    Implement

    do the work: edit, run, build

  4. 04

    Verify

    check it actually worked; loop if not

Verify → GatherIf verify fails, it loops back and gathers again. The cycle repeats until the job is done.

Everything you’ll learn (better prompts, skills, memory) makes one of these four steps better.

The loop every coding agent runs: gather, plan, implement, verify.

Gather, plan, implement, verify. Everything else you learn, whether plan mode, contracts, sub-agents, or hooks, improves one of those four steps.

#5MCP, APIs, and connectors

MCP gets mentioned like a magic word. It is not one, and if the terms API and MCP have confused you, you are in good company. Here is the plain version. An API is a connection that lets one program use another system’s data: instead of you opening gmail.com, your agent reads your email through the Gmail API. MCP (the Model Context Protocol) is a standard way to package an API for agents, with instructions on how to use it; think of it as a skill for using an API. APIs and MCP servers are more alike than different. Most people now meet MCP as a connector: a packaged integration that you switch on inside the Claude or ChatGPT app. Many connectors are built on MCP. Agents reach data in two ways:

  • Tool use, the easy and reliable way. If a service has a connector, you switch it on and sign in. If it has only an API, the agent will usually tell you what it needs; you copy a key from the service’s settings, and the agent handles the rest.
  • Computer use, for sites that only work through a login screen. Your agent opens a browser, takes a screenshot, finds the username box, and clicks through, reading each new screenshot as it goes. Browser tools such as Claude in Chrome do this, and as of September 2026 so do the desktop apps from Anthropic and OpenAI. Computer use remains slower and less reliable than a connector or an API, so do not rely on it for anything critical.

When there is no connector at all, there is often still a way. If the data is on your computer, it sits inside some piece of software, and the agent can often write code to get it out. One client’s notes were locked in OneNote’s binary format, so Claude installed a parser library, wrote a Python script, and converted the files to text. Agents can be lazy: one may tell you it needs a connector, but if you push, it will often find a way. One calibration note: in this curriculum, MCP is a preview, not a deliverable. In our pilot it stayed conceptual for every participant, so do not feel behind if it stays abstract for now.

#6Context hygiene: new task, new session

I repeat this discipline more than any other, because it is mechanical and it quietly wrecks work when ignored. Every context window fills up, and a fuller window makes a worse model. Part 1 gave the rule of thumb: returns diminish past about 20% of the context window, and errors appear past 50%. Slower responses are the sign that the context has grown long. Four rules follow:

  • One chat per problem, not per project. By the eighth or ninth question, the model loses track of what the chat is for.
  • Do not stretch a chat past a task or two. As the context ages, the model makes mistakes and forgets what it said earlier.
  • If it makes mistakes early, start over. An early mistake means the session is already off track, so open a new chat.
  • Carry forward; do not drag forward. Say: “We are at 30% context. I want to start a new chat. Write a detailed carry-forward document, and here is the specific thing I want to do next.”

A fresh chat behaves better for a deeper reason, which ties back to Part 1: the model is a next-token predictor. If it handled something lazily earlier in the conversation, it is more likely to repeat that pattern. A cluttered history primes laziness, and a clean window primes good work. When a skill mysteriously will not fire, the cause is often a messy conversation history rather than the skill.

Sub-agents make context hygiene scale. Imagine giving the agent one more tool: the ability to start a fresh LLM call. The new call, with a clean context window, reads your entire website (say, 50,000 words), digests it independently, and returns a 5,000-word summary to the main agent. That is a sub-agent. Its purpose is to keep the main agent’s context clean, which is why research is best handed to sub-agents. Sub-agents cost real money, since three of them can turn 100,000 tokens into half a million, but more tokens spent on a problem generally produce better output, so spend them. Verification works the same way: have a different agent grade the work, or have two or three review the same output and compare. Fresh eyes catch what a tired context missed. One caution: more agents are not automatically better. A group of agents can settle on the most cautious answer, much as a committee of strangers does, and none of them replaces your own critical thinking. Part 3 covers combining sub-agents and skills into a single capability.

One more advanced safeguard is worth naming now: hooks. A prompt is a request that the agent may or may not honor. A hook is your own code that runs automatically at fixed points (session start, session end, the end of each turn), and the model does not get a vote. Hooks prevent problems; sanity-check scripts detect them. Use hooks to add certainty to a system that is not deterministic: load context at the start, file your work at the end, and run a check after every turn. Later parts return to hooks for the self-updating brain and scheduled work.

A quick word on git, because it trips up nearly everyone. Once the agent starts saving and versioning your work, you will eventually hit one mess: it creates branches, and you lose track of where your real work lives. First, the vocabulary: git is version control on your computer, and GitHub is a service that stores your repositories online. For now, treat git as a way to back up your files. Second, the fix: trunk-based development, which means committing only to your main line. Claude has seen a great deal of professional developer workflow and tends toward elaborate branching you do not need, so put one sentence in your CLAUDE.md: use trunk-based development, not feature branches. Underneath it all, always know where your main line is, and do not let the agent make that decision for you.

#7How to work agentically: 15 / 45 / 15

You have an agent and the core moves. Here is how a working session should run, and how to avoid the trap that stalls most learning.

What happens in session 1The 15 / 45 / 15 method
  1. 15 min

    Concept

    We explain the mental model. You ask questions. Short, prescriptive framing.

  2. 45 min

    Build

    You type. You drive. We guide verbally. You build your first skill from a real task you do weekly.

    You type 80%. We guide.

  3. 15 min

    Wrap

    What you built, what to practice, homework for the week.

The 15/45/15 session: 15 minutes of concept, 45 minutes of you building, and 15 minutes to wrap up. It prevents the consulting trap.
  • 1.15 minutes of concept: short, prescriptive framing that names the idea.
  • 2.45 minutes of building, with you at the keyboard typing 80% of the time. It is not a demo: use your actual recurring work, not a case study.
  • 3.15 minutes to wrap up: what worked, what to capture, and what comes next.

This structure exists to avoid one failure mode I have seen stall session after session: the consulting trap, where the expert does the work and you watch. It feels productive, and nothing transfers. This method is the antidote: you drive, and we navigate. Bring one tedious task you do every week and do it yourself with the agent’s help. Once you stop following instructions and start exploring on your own, you have completed this part.

Now return to the three walls from Part 1. Wall 1, the context reset, starts to disappear, because the agent lives on your file system and reads your folders, skills, and brain automatically. Wall 2, the copy-paste tax, falls away, because the agent operates the software directly: it does not tell you how to make the slide; it makes the slide. Wall 3, the invisible ceiling, lifts, because the agent loops with tools until the job is done, not until it has produced one good paragraph. An agent does not just answer; it acts.

Read the early frustration correctly. As Part 1 put it, friction means you are working at the edge of what the tools can do. You now have an agent on your machine and your hands on the keyboard. Next, give it a skill.

An agent is a folder…with a brain
~/agent/
Identity
CLAUDE.md

who it is, how it works, its lane

Memory
MEMORY

what it knows: state and history

Skills
SKILLS

what it can do: your methods

AgentSkillsPersonal brainthe same folder, deepened

Nothing mystical. The “brain” is just files in a folder: an identity, a memory, and a set of skills: the bridge from a bare agent to a personal operating system.

An agent is a folder with a brain: a CLAUDE.md identity, memory, and skills. This is the bridge into Skills and the personal brain.

The research behind this part.

Continue with the next part.

Want to go faster on your real work?

Coaching is the same method with someone beside you. It is by referral or invitation, and we are at capacity. We write back as capacity opens.