AI Agents & Isolated Context

What is an AI agent?

An AI agent is a language model that autonomously uses tools to accomplish a task, for example, reading files, searching code, fetching web pages, or spawning other agents. The agent decides step by step which tool to call next and when the task is done.

Crucially: every agent starts with an empty context window. On startup it receives a clearly scoped task (a briefing) and returns a result at the end, but all intermediate steps, tool calls, and deliberations stay inside its own context.

Concrete examples from today's tool landscape: Claude Code, OpenCode, Cursor 3 and Cowork are agent-based tools that follow this principle. They typically use the same language models as ChatGPT, Claude.ai or Copilot, but the architecture around them is different. It is that architecture, not the model itself, that delivers the reliability gain.

A reminder: an agent remains a language model, just equipped with tools. Hallucinations therefore occur just as they do in plain chat. With tool access the consequences can even be greater, because depending on the tools' permissions the agent writes files, sends requests or triggers further actions, possibly on the basis of an invented assumption. Tools ease the assembly of context, they do not replace checking the results against the source (see duty to cite).

Isolated context: the central feature

Language models have a limited context window. The more content sits inside it, the slower, more expensive, and less reliable the model becomes. An agent with its own context acts as a sandbox: it consumes context only in its own environment; the calling instance (main chat, orchestrator, another agent) remains unaffected.

Why agents are useful

• Context protection: Large intermediate results (code searches, file contents, tool outputs) do not land in the main context, which stays free for the actual task.
• Parallelization: Multiple independent agents can run simultaneously. Instead of running three research tasks one after another, they run in parallel and results come back almost at the same time.
• Specialization: Different agent types can be equipped with their own system prompts, tool sets, and behavioral rules, for example, an explorer specialized in code search, or a reviewer with a strict evaluation grid.
• Robustness: If an agent fails or runs into a dead end, the main context is not disturbed. You can re-brief and start the agent again.

The personal agent: quality gain or AI slop generator

KI-generiertAI-generated

Agents are moving out of the toolbox and into daily work: as personal assistants that triage mail, prepare appointments, read files and write drafts, operated through the usual messengers rather than a chat surface. The appeal is obvious, and it is real. The flip side comes from the same mechanism, and it cannot be cancelled separately.

On one shoulder sits the assistant that takes work off the desk and does the preparation that would otherwise sit. On the other sits the same model, still inventing things and delivering them in the same calm, well-formed voice as the correct ones. What differs from plain chat is the tool access: an agent does not merely state the invented thing, it acts on it, sends a message, changes a file, books an appointment.

Three limits follow, and they hold up in practice: no agent with unsupervised access to the machine holding client files, no permanently stored credentials, no extension from an open registry without prior review. On substance the chat-era rule stands: every adopted statement is checked against the source (see Duty of evidence). How such an agent fits into a firm's workflow without steps of legal effect drifting over to it is covered in Assistance or integration.

Implications for prompting

Because the agent does not see the calling context, the briefing must be complete. Concretely this means:

• Write self-contained: goal, constraints, approaches already ruled out, expected form of the answer, all of it belongs in the prompt. References like "as discussed earlier" do not work.
• Trust but verify: the agent's response is its description of the outcome, not necessarily what actually happened. For code changes: inspect the diff yourself, not just the summary.
• Right scoping: agents are suitable for self-contained subtasks with a clear return (research, audit, review). For tightly interleaved work where you want to see and steer intermediate states, they are the wrong tool.

Connection to the Prompt Library

The prompt tools in this app (e.g. the Patent Description Generator) are built on the same principle: every generated prompt contains the complete briefing (role, rules, input data, claim text) and can be executed in a fresh chat without any prior knowledge.

The consequence is the same: open a new chat for every individual prompt (general description, claim 1, claim 2, ...).

Why this matters: a fresh chat guarantees a clean context. The relevant inputs are present exactly once, no earlier answer is sitting in the window, and the model has no reason to refer to anything other than the current briefing. This is especially relevant for smaller or local models (gemma3:27b, qwen3:32b, etc.): they get confused easily by prior chat history; they mix sections, repeat phrasings from earlier answers, or let claim wording leak into the general description. Starting over per prompt removes that failure mode entirely: the relevant context is guaranteed to be present, nothing extraneous interferes, and the output becomes reliable regardless of model size, just like an agent running in its own context window.