Context

Context is where you define and control the shared knowledge that agents use while working in a project. It allows you to attach documents, specifications, and other reference material so agent reasoning is grounded in the same information your team relies on.

By managing context explicitly, you ensure that agents understand not just the codebase, but also the intent, constraints, and background behind the work being done.

What Context Is

Context is a centralized space for indexing project-related documents and making them available to agents during interactive sessions.

These documents are treated as first-class inputs to agent reasoning. Once added, they can be referenced when agents explain behavior, answer questions, generate artifacts, or execute tasks.

Context exists to bridge the gap between raw code and the broader project understanding that typically lives in PRDs, design docs, internal notes, or external references.

What Kind of Documents Belong in Context

Context is designed for documents that provide durable, high-signal context about the project.

Common examples include:

• product requirement documents (PRDs),
• technical design documents,
• architecture overviews,
• internal guidelines or standards,
• onboarding notes,
• previously written documentation,
• external specifications or references.

These documents describe what you are building, why it exists, and how it is expected to behave, rather than transient conversation or one-off instructions.

How Documents Are Used by Agents

Documents added to Context are indexed and made available to agents for task discovery and reasoning.

When an agent responds to a prompt, it can:

• reference relevant documents for background,
• align output with documented requirements,
• follow defined constraints or conventions,
• and avoid assumptions that conflict with provided context.

This allows agent behavior to stay consistent with project intent across sessions, tasks, and users.

Example

If a PRD describing authentication flows is added to Context, agents can use it when explaining login behavior, generating tests, or modifying related code.

Adding and Managing Context

Context allows you to add documents individually and control which materials are available to the project.

You can:

• upload or attach files directly,
• expand or collapse indexed documents for inspection,
• add or remove context as the project evolves.

Documents remain available across sessions and are not tied to a single task or trial. This makes them suitable for long-lived project knowledge rather than temporary instructions.

Using Context During Work

Once documents are added, you do not need to restate their contents in every prompt.

Agents automatically consider indexed context when:

• answering questions about the system,
• generating documentation or diagrams,
• proposing changes,
• or reviewing work for alignment with requirements.

You can still reference specific documents explicitly in prompts if needed, but the default behavior is for agents to draw from the full available context.

Why Context Matters

Agent-assisted development is only effective when agents operate with the same understanding as the team.

Context ensures that:

• requirements are not lost between sessions,
• design intent is preserved during iteration,
• and outputs remain aligned with documented decisions.

By making context explicit and persistent, it reduces re-explanation, prevents misalignment, and improves the quality and consistency of agent output.

When to Use Context

Context is especially useful when:

• starting a new project or feature,
• onboarding agents to an existing system,
• working from detailed PRDs or design documents,
• maintaining consistency across multiple sessions,
• or collaborating across teams.

It is less suited for temporary or one-off instructions that apply only to a single interaction.

Boundaries and Control

Context does not modify the repository or execute actions.

Adding a document:

• does not change code,
• does not trigger agent execution,
• and does not expose information outside the project.

Documents are used strictly as contextual input and remain under project-level control.