A small terminal window has been typing away on my homepage for a while now. It looks like a demo, feels like decoration — and that’s exactly the problem I want to clear up here: it isn’t. Every prompt and every tool call reflects a real pattern of how I work with agents. The numbers in the status line, on the other hand, are simulated: the context counter grows plausibly with every step, the speed figure is a random value within a realistic range.
I deliberately built the animation so it doesn’t just simulate “some terminal”, but makes visible the four terms that come up in every conversation about AI agents and are still almost never explained: model, context window, prompt, and token. There’s a fifth, less visible term that holds the whole window together: the harness. Understanding these five terms doesn’t just help you understand my homepage better — it helps you follow any discussion about “AI agents” currently going through every tech briefing.
So I’m turning the animation into a guided tour. The terminal stays visible while you scroll down, and I’ll walk you through, section by section, what each element means right now. No marketing talk — and wherever the animation is simulated, I’ll say so.
The homepage terminal (recreated) — the element being discussed gets highlighted as you scroll. The readings in the status line are simulated.
01 Term 1: MODEL
Right at the bottom of the terminal, at the start of the status line, you see claude-fable-5.2 — a current model from Anthropic, released on November 9, 2026, built for demanding reasoning and long-running agentic work. Exactly the kind of workflow this animation shows.
The model is the actual intelligence behind every step you see in the terminal. It reads the prompt, “understands” (in a statistical sense) the task, and proposes the next action — for example “now I should read the file lean-canvas.md” or “now I should start three subagents.” Important: the model only proposes. It doesn’t type a command into a real terminal, doesn’t open a file, doesn’t start a process. It produces text that looks like a tool call.
What happens to that proposal is decided by a different instance — the harness, which term 5 is about. For now, it’s enough to know: when you see claude-fable-5.2 in the terminal, think “the thinking engine”, not “the program that runs everything.” This distinction is the key to understanding the remaining four terms.
02 Term 2: CONTEXT / CONTEXT WINDOW
Right next to the model name runs a figure like 250K/1M, accompanied by the progress bar [==--------] 25%. That’s the context window — the total amount of text the model can “see” in a single pass before it responds. 1M is the ceiling (here: one million tokens, more on that shortly), 250K is what’s currently used of it: the invisible system prompt, the conversation so far, the current request, and reserved space for the upcoming answer.
The window grows with every step you see in the terminal — every typed prompt, every tool call, every result lands in the context and the bar fills further. Real agent systems behave the same way in principle. The longer the session (one continuous run from the first to the last prompt, without the conversation being restarted), the more files read, the more intermediate steps logged, the fuller the window gets.
And then comes the moment the animation deliberately shows: when the bar gets close to the limit, a “compacting context…” sequence runs, and the counter jumps back. That’s not an error message, but a necessary mechanism: once the window is full, the prior history has to be condensed so new information can still fit at all. Without condensing, the harness would have to simply cut off old content or start a new session. By the way, the model doesn’t do the condensing on its own — the harness does, often by asking the model itself for a summary. Anyone who’s worked with an agent for a while knows this moment — here you get to see it from the outside.
03 Term 3: PROMPT
The input line with the > symbol is the part you notice most directly: the animation types four different prompts one after another, from analyze the lean canvas and plan the website through agent:content → derive structure and copy from the canvas to agent:dev → build, test and ship the page. Each of these prompts is the concrete instruction going to the model — and each triggers a different chain of tool calls below it.
A prompt is more than the single line that gets typed. The first line is the actual user request; the following three are assignments that the orchestrator (the higher-level instance that distributes the work across multiple subagents — more on that in term 5) hands off to its subagents. Every one of these four visible prompts carries an invisible system prompt alongside it — rules I set as the developer beforehand, such as role, tools, boundaries. That applies to every agent, not just my demo.
The animation showing four prompts in a row, instead of just one, is also deliberate: a real agent workflow almost never runs in a single prompt. It’s broken into phases — here: planning, content, design, development — and each phase gets its own focused prompt. That keeps each phase focused and makes the context window from term 2 more manageable.
04 Term 4: TOKEN
The same figure 250K/1M you already saw at the context window is made of tokens — not words, not characters. A token is a unit of text created during so-called tokenization: text is split into pieces that average roughly three-quarters of an English word (German typically needs noticeably more tokens per word because of longer, compound words). Some words are one token; long or rare words get split into several tokens.
The second place tokens show up in the terminal is the figure ↑ 85 t/s at the end of the status line — tokens per time, the common speed measure for language models: how many of these text units are generated per second while the answer is being “written.” In the animation this value is simulated and fluctuates randomly; the demo’s own typing speed is fixed. In real systems, this exact figure determines how fast an answer appears word by word.
That context size and speed are measured in the same unit is no coincidence — it shows how central the token concept is to everything a model does: how much it can “see” (context window in tokens), how much it produces (response length in tokens), and how fast it does that (tokens per second) — all the same base unit, just seen from three different angles.
05 Term 5: HARNESS
Now comes the term that’s the least visible, even though it carries the entire terminal window. Look at the lines with the ⏺ symbol — those are the actions the model proposes: ReadFile(lean-canvas.md), orchestrator.spawn(3 subagents), Bash(curl 127.0.0.1:8188/system_stats), Write(index.html). The indented ⎿ lines below them are what the harness makes of it: the actual result of execution — 9 fields detected..., agent:content · agent:design · agent:dev, performance 97 · SEO 100. Exactly this pair of proposal and execution result is the harness in action.
Remember term 1: the model only proposes actions, it doesn’t execute them itself. The harness is the software layer that actually executes those proposals — it really reads the file, really runs the bash command, really reads back the result — and then writes that result into the model’s context window as the next building block. This loop of proposal → execution → result → next proposal is the actual core of what’s called an “agent” today: agent = model + harness. Without a harness, a model can’t read a file, can’t run a terminal command, and can’t remember anything between two answers — it would be pure text generation with no connection to the outside world at all.
The most striking example of this shows up right in the animation’s first prompt: orchestrator.spawn(3 subagents), followed by agent:content · agent:design · agent:dev. The model proposes the orchestrator.spawn call, but it’s the harness that actually starts three separate model calls, each with its own context and role, collects their results, and merges them. Behind the buzzword “multi-agent system” is, in practice, usually exactly that: a harness orchestrating multiple model runs. The exact same principle is behind the real, considerably more complex setup running ketovavaria.de. You can find more on the AI infrastructure that carries workflows like this on my tech radar page about it.
Named concretely: this site (bernd-zuther.de) runs on the harness Hermes, ketovavaria.de runs on the harness OpenClaw — two different software layers working on the same principle (proposal → execution → result). The call curl 127.0.0.1:8188/system_stats above isn’t a placeholder; it’s the real status check for ComfyUI, the locally running tool used to generate images like the robot mascot in this article — a typical example of a tool that a harness drives for an agent, rather than being a harness itself.
Takeaway
The terminal on my homepage is a simplification — the four prompts don’t actually run quite as linearly and neatly in reality, and some tool results are shortened to fit on one line. Content-wise, though, the animation is accurate: it shows a model that proposes actions, a harness that executes and coordinates them, a context window that fills with every step and eventually needs compacting, and a status line that measures everything in tokens. The real pipelines I work with — like the AI agent workflows behind ketovavaria.de — run more complex, with more subagents, more intermediate steps, and more error handling. But they run on exactly the same basic principle: model plus harness.