
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.
- Read filespull context in
- Write filesproduce output
- Run codeact in the world
- Searchreach the web
An agent = an LLM + a loop + tools.Back and forth, until it gets the job done.
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.
Model
The brain. The exact same model under the hood, whether you chat or operate.
Harness
What you plug the model into so it can do stuff in the world.
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.
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
- 1
Install your CLI agent
Claude Code or Codex: your terminal-native AI.
- 2
Open the terminal, run one command
Type
claudeorcodex, then hit enter. - 3
Navigate to a folder
cdto your project,lsto see files. - 4
Ask one question
“Read this file and summarize it.”
| Tool | Terminal (CLI) | Desktop app |
|---|---|---|
| Claude Code | Mac, Windows, Linux | Mac + Windows |
| Codex | Mac, Windows, Linux | Mac + 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.
- Windows
- Install Git for Windows first; PowerShell works natively for Claude Code.
- Mac
- Run
xcode-select --installfor Git + build tools. - Codex users
- Use the standalone installer. Only the
npminstall 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.
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.
- 01
Gather
pull in the context: files, docs, the task
- 02
Plan
decide the approach before touching anything
- 03
Implement
do the work: edit, run, build
- 04
Verify
check it actually worked; loop if not
Everything you’ll learn (better prompts, skills, memory) makes one of these four steps better.
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.
- 15 min
Concept
We explain the mental model. You ask questions. Short, prescriptive framing.
- 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.
- 15 min
Wrap
What you built, what to practice, homework for the week.
- 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.
who it is, how it works, its lane
what it knows: state and history
what it can do: your methods
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.
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.