How it works
An agent starts with the instructions and context needed for the current job: its objective, operating boundaries, available tools, and the state it must respect. The harness keeps other material accessible without placing it all in the initial context. As the agent reaches a decision that needs more detail, it requests or receives a relevant slice. That slice might be a repository file, an earlier decision, a tool description, or a retrieved record.
A useful disclosure loop has four steps:
- Identify the decision the agent is trying to make.
- Select the smallest context slice that can inform that decision.
- Attach its source and scope so the agent can distinguish evidence from instructions.
- Record what was disclosed and whether the agent used it correctly.
The trigger matters. A file should appear because the agent is working in its directory, for example, or because a tool call needs its contract. Merely having information available does not mean it belongs in every prompt. The harness can expose a summary first and let the agent inspect the underlying material when the summary is insufficient.
Progressive disclosure still needs a stable baseline. If essential constraints are withheld until after an action, the agent cannot reliably follow them. Permissions, stop conditions, and the current objective belong at the point where they govern behavior.
Why it matters in an agent harness
Context affects what an agent can notice and what it may treat as authoritative. Loading every available document at once can bury the current task among stale notes and irrelevant detail. Loading too little can leave the agent guessing about a tool, a prior commitment, or the state of an operation. Progressive disclosure makes that choice part of the harness design instead of an accidental consequence of prompt size.
For control, the harness can put durable instructions in the starting context and bring in task evidence only when needed. A retrieved page can inform an answer without being allowed to redefine the agent’s permissions. This boundary must be explicit: source content may contain imperative language, but its presence in context does not grant it authority.
For observability, record each disclosure with its trigger, source, version or retrieval point, and the decision it was meant to support. When an agent makes a poor choice, an operator can ask whether the needed information was absent, late, misleading, or ignored. Those are different failures and call for different fixes.
Progressive disclosure also changes evaluation. A test should cover the moment information becomes necessary, not only the final answer. An agent that succeeds after receiving a hidden hint has not demonstrated that it can find the right context. Conversely, a failure caused by a missing disclosure should not be mistaken for a reasoning failure.
The tradeoff is another control path to maintain. Disclosure rules can be too narrow, leaving the agent stuck, or too broad, reproducing the original context overload. I would make the trigger and source visible before trying to optimize how much material each step saves.
Progressive Disclosure vs Context Compaction
| Design choice | Progressive disclosure | Context compaction |
|---|---|---|
| Main question | What additional information should enter context now? | What information already in context should be condensed or retained? |
| Typical trigger | The task reaches a decision that needs more detail. | The running context becomes difficult to carry forward. |
| Main risk | Needed information arrives too late or never arrives. | A summary drops a constraint or changes the meaning of prior work. |
The distinction changes where to intervene. If an agent never sees the tool contract it needs, improve disclosure. If it saw the contract earlier but a later summary lost a restriction, inspect compaction and state preservation. A harness may use both, but each needs its own trace and failure checks.
The Rifty take
We optimize for a small, dependable starting context and deliberate access to deeper material. We accept the cost of an extra lookup when it makes the source and timing of a decision easier to inspect. We keep governing constraints available before the actions they govern; progressive disclosure is for relevant detail, not delayed authority.
Implementation checks
- Put the objective, permissions, and stop conditions in context before the agent can act on them.
- Define disclosure triggers around concrete decisions, such as opening a file before editing it or reading a tool contract before calling it.
- Label disclosed material with its source and scope. Keep retrieved content separate from governing instructions.
- Give the agent a way to request more detail when the first slice is insufficient.
- Trace what was disclosed, when, and why, including unsuccessful retrievals.
- Evaluate missing, late, irrelevant, and misleading disclosures separately from failures to reason over available context.
Frequently asked questions
What belongs in the agent’s starting context?
The starting context should contain the current objective, governing instructions, permissions, stop conditions, and enough state to choose the next safe step. Task-specific records and detailed references can be disclosed when needed. If information must constrain an action, it must be available before that action is possible.
How does the harness decide when to disclose more context?
Tie disclosure to a decision the agent is about to make, such as selecting a tool, editing a file, or interpreting a retrieved result. The trigger can come from workflow state or an agent request. Record the trigger so a later review can distinguish an unavailable source from information the agent ignored.
Does progressive disclosure replace retrieval?
No. Retrieval finds candidate information; progressive disclosure decides when and how that information enters the agent’s working context. A harness may retrieve on demand, prepare sources in advance, or use both. In each case, it should preserve source identity and prevent retrieved text from becoming an instruction.
What is the most common design failure?
A common failure is withholding a constraint until after the agent has already made the decision it governs. Another is disclosing a large, unlabeled bundle that obscures which source matters. Check the decision point, the timing of disclosure, and the source label before adjusting the amount of context.