> ## Documentation Index
> Fetch the complete documentation index at: https://mainbranch.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Supported AI agents: Claude Code, Copilot, Cursor, Windsurf

> How Claude Code, Cursor, Windsurf, GitHub Copilot, and OpenClaw each read AGENTS.md, handle session logging, and behave with subagents.

The Agent Context System works with every major AI coding tool by meeting each agent where it expects its instructions. `AGENTS.md` is the single source of truth. Each tool reads it through its own config file — a symlink, a directive, or natively — so you write your project context once and every agent picks it up.

## Compatibility table

| Agent          | Config file                       | How it reads AGENTS.md                                 |
| -------------- | --------------------------------- | ------------------------------------------------------ |
| Claude Code    | `CLAUDE.md`                       | Symlink → `AGENTS.md`, created by `agent-context init` |
| Cursor         | `.cursorrules`                    | Directive: `Read AGENTS.md before starting`            |
| Windsurf       | `.windsurfrules`                  | Directive: `Read AGENTS.md before starting`            |
| GitHub Copilot | `.github/copilot-instructions.md` | Directive: `Read AGENTS.md before starting`            |
| OpenClaw       | Native                            | Reads `AGENTS.md` directly, no config file needed      |

***

## Agent details

<AccordionGroup>
  <Accordion title="Claude Code">
    Claude Code reads its instructions from `CLAUDE.md`. Because Claude Code does not read `AGENTS.md` directly, `agent-context init` creates a `CLAUDE.md` symlink that points to `AGENTS.md`. From Claude Code's perspective, it is reading `CLAUDE.md` — the content is identical to your `AGENTS.md`.

    **Session logging:** Claude Code shipped auto memory in late 2025. It writes session notes to `~/.claude/projects/<project>/memory/` and loads them automatically at session start. This covers the same job as `.agents.local.md` for Claude Code users specifically.

    If you use Claude Code exclusively, auto memory handles session-to-session learning and the scratchpad is optional. The template still adds value through `AGENTS.md` itself and the promotion pathway — a structured way to take what the agent learns and move stable patterns into your committed context file.

    If your team uses multiple agents alongside Claude Code, the scratchpad matters because auto memory only works inside Claude Code. `.agents.local.md` works everywhere.

    **Special considerations:**

    * If a `CLAUDE.md` file already exists as a plain file (not a symlink), `init` skips the symlink step and warns you. Reconcile the two files manually.
    * The template's Rule 1 explicitly applies to subagents: "This applies whether you are the main agent or a subagent."
  </Accordion>

  <Accordion title="Cursor">
    Cursor reads `.cursorrules` at session start and applies it as project-level instructions. `agent-context init` adds a single directive to `.cursorrules`:

    ```text theme={null}
    Read AGENTS.md before starting
    ```

    This tells Cursor to load `AGENTS.md` as part of its context before it responds.

    **Session logging:** Cursor does not have a session-end hook. Session logging depends on Rule 7 in `AGENTS.md` being read and acted on. The most reliable approach is to explicitly tell Cursor to log the session when you are finished: "Log this session to `.agents/logs/YYYY-MM-DD.md`."

    The agent will propose the log entry and wait for your approval before writing.
  </Accordion>

  <Accordion title="Windsurf">
    Windsurf reads `.windsurfrules` the same way Cursor reads `.cursorrules`. `agent-context init` adds the directive to `.windsurfrules`.

    **Session logging:** Same as Cursor — no automatic session-end hook. Prompt Windsurf to log the session when you finish.
  </Accordion>

  <Accordion title="GitHub Copilot">
    GitHub Copilot reads `.github/copilot-instructions.md` as its project-level instructions file. `agent-context init` adds the AGENTS.md directive there.

    **Installation via skill registry:**

    ```bash theme={null}
    npx skills add AndreaGriffiths11/agent-context-system
    bash .agents/skills/agent-context-system/scripts/init-agent-context.sh
    ```

    This method installs the system as a Copilot skill and runs the init script automatically.

    **Session logging:** Copilot Chat does not have a session-end hook. Prompt it to log the session explicitly. Copilot CLI's `/fleet` command has experimental subagent support — see the subagents section below.

    **Special considerations:** Copilot Memory learns about you as a developer (preferences, style). Agent-context handles what every agent needs to know about your project. The two systems are complementary.
  </Accordion>

  <Accordion title="OpenClaw">
    OpenClaw reads `AGENTS.md` natively as part of its workspace skill system. No config file or directive is required.

    **Installation:**

    ```bash theme={null}
    git clone https://github.com/AndreaGriffiths11/agent-context-system.git skills/agent-context-system
    ```

    Restart your OpenClaw session. It picks up `AGENTS.md` automatically.

    You can also install via ClawHub:

    ```bash theme={null}
    clawhub install agent-context
    ```

    **Session logging:** OpenClaw supports the session-end logging workflow through the instruction in Rule 7 of the template.

    **When you might not need agent-context:** If OpenClaw is your only coding agent, the system adds less value because OpenClaw reads `AGENTS.md` natively anyway. Where it becomes useful is when your team uses OpenClaw alongside other agents — `AGENTS.md` becomes the shared project context that works across every tool, not just OpenClaw.
  </Accordion>
</AccordionGroup>

***

## Subagents

### Claude Code subagents

Claude Code can spawn subagents that run tasks in parallel. Each subagent starts with a clean context window — it does not inherit the main conversation's history. The only shared knowledge across all subagents is your root instruction file.

When you go from one agent to five parallel agents, `AGENTS.md` goes from "helpful project context" to the only thing preventing five agents from independently making conflicting decisions about your codebase.

This is why the template's Rule 1 explicitly tells subagents to read `.agents.local.md` too:

> "Read this file and `.agents/local.md` (if it exists) before starting any task. **This applies whether you are the main agent or a subagent.**"

Subagents will not read the scratchpad unless they are explicitly instructed to. Without that instruction, each one starts from scratch.

Keeping `AGENTS.md` under 120 lines matters even more in a subagent context. If your context file is 500 lines, you pay that token cost for every subagent spawned.

### Copilot CLI /fleet

GitHub Copilot CLI's `/fleet` command dispatches parallel agents with dependency-aware task execution. Support with the Agent Context System is experimental. The same principle applies: each fleet agent starts fresh, so `AGENTS.md` is the shared brain.

<Info>
  The subagent context isolation problem is the strongest reason to maintain a lean, dense `AGENTS.md`. Verbose context that works fine with a single agent becomes expensive and potentially unreliable when multiplied across a fleet.
</Info>