Agentic
AI.
How Claude Code, Codex & co. actually work
You type one line. It does the rest.
That autonomy — deciding and acting, step after step — is what makes it an agent. The rest of this talk is simply how it works.
A chatbot answers. An agent acts.
You ask → it tells you what to do → you open the files, run the commands, paste the errors back… and repeat.
You ask → it does the work itself — reads the files, runs the commands, checks the result → you review at the end.
Often it's the same model underneath. The difference is everything wrapped around it — and that's exactly what's next.
Meanwhile — a real agent is working
I just set Claude Code loose on a real task. It runs while we talk — we'll check back when we hit the loop, thinking, and context.
What we'll cover
Model, harness, agent — the loop that ties them together, and how it "thinks".
Today's models & tools, prices and plans.
The model's short-term memory — and how to keep it sharp.
Permissions: ask, auto, and bypass ("YOLO") mode.
CLAUDE.md, memory, skills & plugins.
APIs, CLIs and MCP — touching other systems.
Three building blocks
The one line to remember: "agent" means it does something. The model alone only predicts text — the harness gives it hands, and the agent is this whole back-and-forth, on a loop.
Words you'll keep hearing
Don't worry about memorising these — every one gets a slide of its own. This is just your map.
The model has no memory
- A model is autocomplete on steroids — it only ever predicts the next word (token). Text in, text out. No database, no "you".
- Think of the guy in Memento — the film hero who can't form new memories, living off notes & tattoos: each interaction, the model has no idea what we said before.
- So the harness must re-send everything it should know, every single call.
"No memory" in practice
There's no "conversation" on the model's side. Each call hands it the whole history as one flat list:
Delete the first line and the model can't answer. The "memory" lives in the request — not the model.
Model in the cloud, harness on your machine
You talk to the agent. Claude Code is the harness — it runs locally with your files & terminal, and loops with the model in the cloud (which stays stateless). The agent isn't a separate thing — it's that loop.
What one turn really sends
EXAMPLE — a single Claude Code promptOne line in → thousands of tokens of context out. And it does this again on every turn.
An agent is a loop
- ① the model proposes an action → ② the harness runs it → ③ the result comes back. Repeat until ④ done.
- Like a cook: read the recipe → do a step → taste → adjust → repeat.
- This loop is the whole "magic" of agentic AI — no magic, just disciplined repetition.
● LIVE Glance at our running agent — those scrolling tool calls are this loop, for real.
Our hook, as the loop
Each line is one ①→②→③ lap of the loop. The model never "ran" anything itself — the harness did, and reported back each time.
The model thinks before it answers
- Reasoning (or "thinking") models work the problem out step by step first — a private scratchpad — then give the answer.
- It's still next-token prediction, just allowed to "think out loud." Empirically far better at maths, coding & planning.
- More thinking → better on hard problems — but past a point it overthinks and gets worse.
- Usually a dial: low / medium / high effort. Newer Claude models decide adaptively how hard to think.
● LIVE Watch for a thinking block in our running agent before it takes its next action.
Thinking inside the loop
- In the loop, the model thinks before each action: which tool, why, did the last result work? → better plans, fewer wrong turns.
- It isn't free: thinking tokens are billed as output and fill the context window — so don't crank the effort for simple jobs.
- Rule of thumb: hard, multi-step task → think more; quick edit → think less.
Anthropic's own research (2025): when a hidden hint changed the model's answer, its reasoning mentioned that hint only ~25% of the time. The visible "thinking" is a helpful narration — not proof of what really happened.
What it's actually good for
Features, refactors, bug fixes, writing tests.
"Where is X handled?" — answers grounded in your repo.
Triage issues, bump dependencies, wire up CI.
Query docs, tickets, databases (via MCP).
Summaries, emails, first drafts, comparisons.
You review & approve. It's a power tool, not a replacement.
The landscape
A quick detour through today's models, tools and prices — then we're straight back to how it all works.
Today's best models
| Maker | Flagship lineup (July 2026) | Known for |
|---|---|---|
| Anthropic | Claude Fable 5 · Opus 5 · Sonnet 5 · Haiku 4.5 | coding, agents, long context |
| OpenAI | GPT‑5.6 — Sol · Terra · Luna | general reasoning, Codex |
| Gemini 3.6 Flash · 3.5 Flash‑Lite (3.5 Pro still unreleased) | multimodal, large context |
The same three tiers repeat everywhere: large (smartest, priciest) · medium (the sweet spot) · small (fast & cheap) — and Anthropic adds a frontier tier on top (Claude Fable 5). It reshuffles every few months, so treat any list as a snapshot. How fast does it move? —
SWE-bench Verified — Opus 5 fixing real bugs in real code projects
ARC-AGI-3 — Opus 5 scores 30%, three times the next-best model, on puzzles built to resist memorising
how long "what AI can't do" assumptions stay true
Which tier when?
Hard reasoning, tricky multi-file refactors, architecture. Pricier per word — but on hard work it gets there in fewer steps.
The daily driver. Most coding & agent work. Often beats last gen's flagship at a fraction of the cost.
High-volume, simple, fast: classification, quick edits, sub-agent grunt work.
Example: a cheap Haiku sub-agent skims 200 files and summarises; the pricey Opus only does the actual design call. Cheap legwork, expensive thinking only where needed. But "pricey" is per word, not per job — that turns out to matter, and we come back to it in a few slides.
Today's best harnesses
Anthropic. CLI + IDE + web. Agentic coding over your whole repo.
OpenAI's coding agent on GPT‑5.6 — in your terminal, with a cloud option.
An IDE built around an AI agent.
Agent + autocomplete inside your editor.
Another agentic IDE.
Open-source terminal coding agent.
The harness decides what the model can actually do — tools, sandboxing, memory, parallelism. At least as important as the model.
Same agent, different front door
Lives in your shell, scriptable. Claude Code · Codex · Gemini CLI · Aider.
A standalone window, less terminal-y. Claude Code app · Codex in the ChatGPT app.
Inline with your editor. Claude Code & Codex extensions · Cursor · Windsurf · Antigravity · Copilot.
It's the same loop underneath — just a different front door. Most of the big ones ship in several of these at once; pick whichever fits how you work.
Lovable: describe an app, get an app
- You describe the app in plain language — Lovable builds a working web app: pages, database, login, hosting.
- Then you iterate by chat: "make the header sticky", "add a monthly chart" — it edits the live app.
- Underneath: the same agent loop we just saw, wrapped in a website. Same category: v0, Bolt, Replit.
Example: "Build an expense tracker: add expenses, a monthly chart, login." → minutes later, a running app on a shareable link — source code included.
Higgsfield: video from a prompt
- Text or image in → finished video out: cinematic camera moves, characters that stay consistent across shots.
- An AI director splits your idea into shots, generates each, stitches them — our loop again, different domain.
- Built for marketing & social — even "product URL in → ready-made ad out". Same category: Sora, Veo, Runway.
Example: "A 15-second ad for our mobile bank: phone in hand, city at dusk, upbeat." → storyboard → shots → rendered clip, ready for social.
HyperFrames: agents that make video
- Open-source (HeyGen): a web page with timing attributes in → a pixel-perfect MP4 out.
- Built for agents: Claude Code installs it as a skill, then edits video by chat — the way it edits code.
- Same file in → same video out, every time — ideal for explainers, product demos, captions.
Example: "Turn this slide's diagram into a 20-second animated explainer." → the agent writes the HTML, renders it, hands you the MP4.
Subscriptions (consumer)
| Tier | Claude (Anthropic) | ChatGPT (OpenAI) |
|---|---|---|
| Free | limited usage | limited usage |
| Entry | Pro — ~$20/mo | Go ~$8 · Plus ~$20/mo |
| Power | Max 5× ~$100 · Max 20× ~$200/mo | Pro 5× ~$100 · Pro 20× ~$200/mo |
Higher tiers buy more usage and priority access to the newest models. Prices as of July 2026 — they change often, so verify before quoting.
Subscription vs API
A flat monthly fee for a person using the app or CLI. Simple, capped by usage limits. Best for everyday work.
Pay per token (input + output). No cap, scales to production. Best for building integrations.
Why tokens matter: a long agent session can read your files dozens of times — and on the API you pay for every re-read. That's exactly why caching (coming up) exists.
Cheaper per word, pricier per job
- The instinct: the big model is the expensive one. Per word, that's true — Opus costs 5× Haiku.
- But a weaker model flails: it reads more files, tries more things, gets it wrong, retries. And every retry re-sends the whole conversation — the model has no memory, remember.
- A stronger model gets there in fewer steps — and steps are what you actually pay for. On hard work, the smarter model is often the cheaper one.
Opus 4.5 matched Sonnet 4.5's best coding score — writing 76% less
Opus 5 hit its best score with a seventh of its predecessor's thinking
Sonnet 5 matches the previous Opus on web research, on a third of the tokens
The catch: this only holds when the job is genuinely hard — sorting emails doesn't get cheaper on Opus. Rule of thumb: the cheapest model that actually does the job — and check, don't guess.
Context = the model's short-term memory
- Everything the model sees in one call: system prompt, CLAUDE.md, chat history, files, tool output.
- Measured in tokens. The context window is the max — 1M (≈ 2,500 pages) on today's top models, 200K on the small ones.
- If it isn't in the context, it doesn't exist for the model.
Fuller context = dumber model
- "Context rot" (Chroma): 18 frontier models all got worse as input grew — even when the answer was right there.
- "Lost in the middle" (Stanford): models recall the start & end, but miss facts buried in the middle.
- The "40% threshold of stupidity" is folklore, not a law — but the lesson holds: keep the window well under full. Curation beats capacity.
Watch it, keep it lean
EXAMPLE — a harness status line- Most harnesses show live % used — glance at it.
- Climbing past ~40–50%? Quality starts to slip — time to trim or restart.
- Habit: finish a task, then start a fresh chat rather than dragging a bloated one onward.
● LIVE Check the context % on our running agent right now — see how far it's climbed.
How harnesses cope
Stable parts (system prompt, CLAUDE.md, files) are remembered between calls, so reusing them is much cheaper and faster than re-reading every time.
When the window fills, the harness summarises older turns into a short recap and drops the raw text — freeing space to keep going.
Both are automatic. The catch with compaction: anything not kept in the summary is forgotten — so the summary has to keep what matters.
Sub-agents keep the main context clean
- A sub-agent is a separate agent with its own fresh context for one sub-task.
- It does the messy work and returns only the conclusion.
- Example: "search these 200 files" burns 80k tokens inside the sub-agent — the main chat gets a 200-token answer. They can also run in parallel.
Safety through permissions
- Default · ask — the agent asks first before any risky action (write a file, run a command). Safest.
- Auto · accept edits — pre-approve a class of actions (e.g. file edits) so it won't interrupt on routine steps.
- Bypass · "YOLO" — asks for nothing. Fast, but it can run any command — only in a sandbox.
● LIVE Our running agent is in auto mode — that's why it hasn't stopped to ask. Both Claude Code and Codex ship these modes (Codex calls them read-only / auto / full access). More freedom demands more isolation.
When is "YOLO" OK?
- Only where a mistake can't hurt: a throwaway container or VM, an isolated copy of the project, or an automated build server (CI).
- Never on your main machine with real passwords and no backup.
- Remember: an agent reads files and the web — a hidden malicious instruction in either can hijack a no-questions-asked agent.
thicker walls
The rule: the more autonomy you grant the agent, the more walls you put around it.
Back to the model with no memory
Remember Memento (slide 7)? Every call re-reads the whole context — and keeps nothing afterwards.
- So how do we give it knowledge that survives across sessions…
- …without stuffing the context window full (and rotting it)?
- Four tools: CLAUDE.md, memory, skills and plugins.
Memory that survives sessions
EXAMPLE — CLAUDE.md in your repo root- CLAUDE.md — read at the start of every session; your standing rules & conventions. The agent's notes & tattoos.
- Memory files — durable notes the agent saves and reloads later (some harnesses do this automatically).
Skills & plugins
- Skill = a folder with a SKILL.md (a name + description, plus instructions, scripts, resources).
- Loaded only when needed: the agent reads a skill's full instructions only when a task matches — so you can keep dozens around for almost no context cost.
- Plugins bundle & distribute skills, commands and MCP servers across a team.
Touching other systems
- API — services called programmatically over HTTP. The agent sends a request, gets structured data back.
- CLI — command-line tools the agent runs like a human in a terminal (git, gh, kubectl…).
- MCP — Model Context Protocol, an open standard to plug tools & data into any agent.
CLIs & APIs already exist everywhere — the agent just uses them. MCP is the newer, agent-native way to connect.
MCP = "USB-C for agents"
- Anthropic's open standard (Nov 2024). Stop writing a custom connector for every tool × every app.
- Run an MCP server once; any MCP-aware agent can use it. Thousands now exist.
- Example: "find my next meeting with the audit team and draft a follow-up" — Calendar + Gmail, one agent, no glue code.
If you remember three things
Treat it like a colleague, in plain language. Give the goal & context, then iterate. Natural beats over-engineered prompts.
No context = no idea what you mean. The agent only knows what's in front of it — and quality rots as that fills with junk.
It orients fast from what you give it. Keep a CLAUDE.md; when passing work on, ask it to write a summary for the next agent.
Most of "prompting skill" is really just managing what the agent can see.
What to take away
- Model = a stateless brain · harness = the body & memory · agent = the loop that does things.
- Mind the context — quality rots as it fills; caching, compaction & sub-agents are how we cope.
- Permissions are your safety net; bypass mode only inside isolation.
- CLAUDE.md, memory, skills, MCP = how we give a forgetful model durable knowledge & reach.
Thanks! Questions?
David Budáč
Sources & links (1/2)
Models & pricing
Anthropic — Claude models overviewplatform.claude.com/docs · models Claude — plans & pricingclaude.com/pricing Anthropic — Claude Opus 5 (benchmarks)anthropic.com/news · claude-opus-5 Anthropic — Opus 4.5: effort & token efficiencyanthropic.com/news · claude-opus-4-5 OpenAI — GPT-5.6 (Sol · Terra · Luna)openai.com/index/gpt-5-6 ChatGPT — pricing tierschatgpt.com/pricing Google — Gemini 3.5blog.google · gemini-3-5Sources & links (2/2)
Context, caching & reasoning
Anthropic — Effective context engineeringanthropic.com/engineering Chroma — Context Rot (18-model study)trychroma.com/research/context-rot Liu et al. — Lost in the Middlearxiv.org/abs/2307.03172 Anthropic — Prompt cachingplatform.claude.com/docs · prompt-caching Anthropic — Extended / adaptive thinkingplatform.claude.com/docs · extended-thinking Anthropic — Reasoning models don't always say what they thinkanthropic.com/research · cot-faithfulnessAll figures verified July 2026. Models & prices move fast — re-check the primary sources before quoting.