What AI coding agents actually write to your disk in 2026 — Claude, Codex, Cursor, Gemini, Continue, Copilot, Aider, OpenClaw

Most developers running an AI coding agent daily never look at what it writes to disk. Open ~ and you’ll find anywhere from one to eight hidden directories that each agent uses as its working memory — preferences, project conventions, session transcripts, tool-call traces. Together they grow at roughly 5–20 MB per day per active agent, and quietly accumulate forever unless you go looking.

This article maps exactly what every major agent puts where, what to keep, and what to prune. If you only run one agent it’s still worth knowing — and if you run several (which is what we’re seeing in 2026), the picture gets crowded fast.

The 30-second summary

Agent	Primary location	Persistent context	Session telemetry	Footprint per active day
Claude Code	`~/.claude/`	`CLAUDE.md`, `<project>/CLAUDE.md`	`~/.claude/projects/*.jsonl`	5–15 MB
Codex (OpenAI)	`~/.codex/`	`AGENTS.md`, `instructions.md`	`~/.codex/sessions/*.jsonl`	3–10 MB
Cursor	`~/Library/Application Support/Cursor/`	`.cursorrules`, `<project>/.cursor/`	SQLite DB, conversation history	10–40 MB
Gemini (Google)	`~/.gemini/`	`GEMINI.md`, `<project>/GEMINI.md`	`~/.gemini/sessions/`	2–8 MB
Continue.dev	`~/.continue/`	`.continuerc.json`, `config.yaml`	`~/.continue/dev_data/*.jsonl`	2–6 MB
GitHub Copilot	`~/Library/Application Support/Code/User/globalStorage/github.copilot/`	`copilot-instructions.md`	Encrypted activity logs	<2 MB
Aider	`~/.aider/`	`.aider.conf.yml`, `CONVENTIONS.md`	`~/.aider.input.history`, `~/.aider.chat.history.md`	1–5 MB
OpenClaw	`~/.openclaw/`	`CLAW.md`, `<project>/.claw/`	`~/.openclaw/runs/*.jsonl`	3–8 MB

Per-agent breakdown

Claude Code

Claude’s footprint is the most opinionated and the most legible of any 2026 agent. Two layers:

Persistent context: walked-up CLAUDE.md files (~/.claude/CLAUDE.md global, <project>/CLAUDE.md per-repo, <subdir>/CLAUDE.md per-module). Plain markdown. Concatenated automatically.
Session telemetry: every conversation is logged as line-delimited JSON in ~/.claude/projects/-Users-you-path-to-project/<session-id>.jsonl. Every tool call, every read, every edit, every response. Files routinely cross 10 MB on long sessions.

What matters in .jsonl: searching for "type":"tool_use" entries gives you a complete audit of what Claude did. We do this when something went wrong and we want to know exactly which file it touched.

Codex (OpenAI’s terminal agent)

Closer to Claude Code’s design than to Aider. Codex uses:

AGENTS.md (preferred) / instructions.md — same layered model as CLAUDE.md. Codex also reads CLAUDE.md if present (good for cross-agent projects).
~/.codex/sessions/<session-id>.jsonl — session log. Smaller and more compact than Claude’s, because Codex inlines fewer tool results.
~/.codex/skills/ — newer (early 2026) location for installable skill manifests.

Codex transcripts are particularly useful because they include the original user message verbatim, plus what the agent inferred from it. We’ve used them to catch cases where the agent silently reinterpreted the request.

Cursor

The heaviest disk-footprint of any tool here, because Cursor stores everything in a SQLite database under ~/Library/Application Support/Cursor/. That includes:

User/globalStorage/cursor.cursor/state.vscdb — conversation history, full
User/workspaceStorage/<workspace-hash>/ — per-project context
.cursorrules in each project root

Cursor’s conversation history is the hardest to inspect because it’s binary (SQLite). The official way to view it is in Cursor itself. We’ve seen this trip people up — they want to audit past conversations and there’s no plain-text option without third-party tools.

Gemini (Google’s CLI agent)

Similar layered model to Claude: GEMINI.md files at global, project, and module level. Storage in ~/.gemini/:

~/.gemini/settings.json — config
~/.gemini/sessions/<id>.json — chat history (note: .json, not .jsonl)
~/.gemini/checkpoints/ — Gemini-specific staging area for proposed changes

Gemini’s checkpoint system is unique among the agents — it stages proposed edits in a separate directory before applying, so you can diff and revert. Worth knowing about if you do safety-critical work.

Continue.dev

Continue is the only agent here that’s primarily a VS Code / JetBrains extension rather than a CLI. Its disk footprint sits in ~/.continue/:

config.yaml (newer format) or .continuerc.json (legacy) — model + tool config
dev_data/*.jsonl — anonymized telemetry (opt-out via allowAnonymousTelemetry: false)
index/ — local code embeddings (can grow large on big repos, prune with continue clean)

Continue is the lightest on conversation history because it doesn’t store full transcripts by default — only what you mark for retention.

GitHub Copilot

The lightest disk footprint and the least transparent. Everything is encrypted under ~/Library/Application Support/Code/User/globalStorage/github.copilot/. The one file you can directly write to:

<project>/.github/copilot-instructions.md — the only persistent-context primitive Copilot exposes

If you want to audit Copilot history, you have to do it from inside VS Code (Activity log panel). There’s no equivalent of cat ~/.claude/projects/*.jsonl.

Aider

The most file-system-native of the bunch — Aider treats your git repo as the source of truth and writes minimally to disk:

~/.aider/.aider.conf.yml — global preferences (model, edit format)
<project>/.aider.conf.yml — per-project override
<project>/CONVENTIONS.md — Aider’s name for the persistent context file
~/.aider.input.history — your past inputs (deduped, line-by-line)
~/.aider.chat.history.md — chat history in markdown (not JSON), human-readable

The markdown chat history is the single best demo of Aider’s “git history is human-readable” philosophy — you can tail -f it like a log file during a long session.

OpenClaw

The newest entrant (mid-2026), positioned as Claude Code’s open-source competitor. Storage in ~/.openclaw/:

~/.openclaw/CLAW.md (global) and <project>/.claw/CLAW.md (per-project)
~/.openclaw/runs/<run-id>.jsonl — session logs, structurally similar to Claude’s
~/.openclaw/cache/ — model output cache (can be cleared safely)

OpenClaw’s runs log includes a parent_run_id field that Claude Code’s doesn’t — useful when you spawn subagents and want to trace the full tree.

What to prune (safely)

After running multiple agents for a few weeks, your ~ accumulates GB of cruft. Safe-to-delete vs. keep:

Delete freely:

~/.claude/projects/<old-project>/*.jsonl — once a project is done, transcripts have no archival value
~/.cursor workspaceStorage for repos you’ve deleted
~/.continue/index/<old-repo>/ — embeddings rebuild on next use
~/.openclaw/cache/

Keep:

All CLAUDE.md / AGENTS.md / GEMINI.md / CLAW.md / CONVENTIONS.md files — these are your accumulated wisdom
Latest session transcript for any project you might revisit — it’s the only record of “what the agent decided”
All .aider.chat.history.md — small, human-readable, sometimes contains decisions worth keeping

Audit periodically:

Check du -sh ~/.claude/projects/* quarterly — single sessions can blow up to 100+ MB and warrant pruning
Watch ~/.continue/index/ if you work on monorepos — embeddings can hit GB scale

How to actually look at this

The tooling story here is the weakest part of the AI coding agent ecosystem in 2026. The defaults:

Terminal: cat, jq, grep work, but JSONL files routinely exceed what’s comfortable to scroll
VSCode: opens 1+ MB files but stalls on the multi-MB session transcripts that Claude and Codex routinely produce
TextEdit / Notes: fine for the markdown context files, useless for telemetry

We made AI Memory Reader (disclosure: our project) to fill that gap — a native macOS app that auto-discovers all eight directories above and chunk-renders the multi-MB JSONL files so they don’t stall. Free, open source, no signup. It exists because we got tired of waiting for vim to load a 40 MB transcript.

Why this matters

Three pragmatic reasons to know what’s on disk:

Debugging: when an agent does something wrong, the JSONL transcript is the only source of truth. Knowing where to look saves hours.
Privacy: most of these files contain your code verbatim. If you ever publish a profile dump or contribute disk images, you want to know what’s in them.
Cross-pollination: rules you discover writing for Claude often transfer to Codex or OpenClaw with minimal rewrite. Knowing both files helps you reuse.

The agents themselves don’t surface this — most users discover the directories by accident, often after several gigabytes of accumulation. Treat them as part of your dev environment, prune them, and read the transcripts when something is off.

This article is part of bestagent.dev — independent reviews of AI coding tools written by working engineers. We run six of the eight agents listed above in daily production work; the other two (Copilot, Continue) we’ve used long enough to inspect their disk footprint but no longer run continuously. Disclosure: we make AI Memory Reader. No other tools mentioned here paid for placement.