Competing Tools Comparison

How 9 AI coding assistants handle memory, context, and persistent knowledge across sessions.

Summary Table

Cursor

Instructions

Moved from legacy .cursorrules to .cursor/rules/ directory with .mdc files. Each supports frontmatter with description, globs (file pattern scoping), and alwaysApply. Rules can be always-on, manually invoked, or auto-attached based on glob patterns.

Memory

The Memories feature (2025) persists facts from conversations and applies them in future sessions. Per-project knowledge base of conventions, specifics, and preferences.

RAG/Indexing

The most sophisticated publicly documented RAG pipeline:

• AST-based chunking via tree-sitter (functions, classes — not arbitrary lines)
• Custom embedding model trained on agent sessions
• Vector storage in Turbopuffer (serverless)
• Merkle tree diffing for incremental re-indexing (~10 min cycles)
• 12.5% improvement over keyword search
• Dynamic Context Discovery (Jan 2026): agent discovers context as it works, not upfront

Limitations

• .mdc format is proprietary, not portable
• Memory feature can be opaque
• 32 KiB practical cap on combined rule content

Windsurf (Codeium)

Instructions

Three scopes: Global, Workspace (.windsurf/rules/), System-level. 6,000-char per-rule limit, 12,000-char total active limit. Rules can be "Always On" or @-mentioned.

Memory

Cascade has auto-generate memories: stores context it deems useful during conversation. Stored at ~/.codeium/windsurf/memories/. Toggle for auto vs explicit-only.

Context Pipeline

Every interaction: load Memories → read open files → run codebase retrieval → read recent actions → assemble prompt.

Limitations

• Character limits (6K/12K) are restrictive
• No user control over memory pruning/editing
• Memory quality depends on what Cascade decides is "worth remembering"

GitHub Copilot

Instructions

.github/copilot-instructions.md for repo-level. Also .github/instructions/*.md with YAML frontmatter for scoped instructions. Priority: Personal > Repository > Organization.

Memory

No built-in cross-session memory. Copilot Spaces (replaced Knowledge Bases, Nov 2025): curated docs/code/context accessible via MCP from any IDE.

RAG

Workspace indexing + LSP intelligence + semantic search. Server-side. 100K character context in chat (April 2025).

Limitations

• No persistent per-user memory
• Custom instructions invisible in chat UI
• All indexing is server-side (no local option)

Aider

Instructions

CONVENTIONS.md loaded via .aider.conf.yml with read: CONVENTIONS.md. Config cascades: home dir < git root < cwd.

Memory

No persistent memory. Each session starts fresh. CONVENTIONS.md and the repo map are the persistent layer.

Context

Signature feature: repository map via tree-sitter AST parsing. Static analysis (not embeddings). Users manually add files; repo map handles peripheral context.

Limitations

• No RAG/semantic search
• No cross-session memory
• Context management is largely manual

Continue.dev

Instructions

.continue/rules/ directory. .continuerc.json overlays global config with mergeBehavior.

RAG

Full RAG pipeline with @codebase context provider: tree-sitter parsing + ripgrep + embeddings in LanceDB. Configurable embedding models (voyage-code-3 cloud or nomic-embed-text local).

Context Providers

Extensible @-mention system: @file, @codebase, @open, @terminal, @diff, @docs, @repo-map, @url. Custom providers in TypeScript/Python.

Limitations

• No auto-memory
• RAG quality depends heavily on embedding model choice
• Community reports inconsistent @codebase retrieval accuracy

Cline / Roo Code

Instructions

.clinerules files or .clinerules/ directory with multiple markdown files.

Memory Bank

Cline's signature methodology — structured markdown files that the AI reads at session start:

• projectbrief.md — project overview and goals
• productContext.md — product requirements
• activeContext.md — current work state
• systemPatterns.md — architecture patterns
• techContext.md — tech stack, dependencies
• progress.md — done/in-progress/blocked

Limitations

• Convention/methodology, not built-in — depends on AI faithfully following .clinerules
• No vector search or embeddings
• All memory files loaded every session (no routing)

OpenAI Codex CLI

Instructions

AGENTS.md files with hierarchical cascade: global ~/.codex/AGENTS.md → project directories. 32 KiB combined cap.

Memory

Stores session transcripts locally with a resume subcommand. Lighter than true persistent memory but allows continuity.

Limitations

• No vector search or codebase indexing
• 32 KiB instruction cap
• Memory relies on transcript resume, not semantic recall

Amazon Q Developer

Instructions

Project rules in .amazonq/rules/ as markdown. Support priority levels.

Memory Bank

Adopted the Memory Bank methodology (from Cline). Auto-generates memory bank files by analyzing the project. Can regenerate when project changes. Custom rules control generation.

Limitations

• Heavily AWS-ecosystem oriented
• Auto-generated = less user control over structure

Zed AI

Instructions

.rules at project root. Also reads .cursorrules, CLAUDE.md, AGENTS.md (first match wins). Rules Library UI for managing defaults.

Context

Explicit approach: manually drag files/code into Agent Panel, @-mention files/dirs/symbols/threads. Full transparency at the cost of manual curation.

Limitations

• No RAG or codebase embeddings
• No auto-memory
• Smaller ecosystem

Industry Trends (2025-2026)

1. Convergence on markdown rules files: Every tool now supports project-root instruction files. The naming varies but the pattern is universal.
2. Memory Bank as industry pattern: Originated in Cline, structured-markdown memory banks are now the de facto standard.
3. RAG is differentiating but not universal: Cursor and Continue have sophisticated pipelines; most others rely on static analysis or explicit context.
4. Scoped instructions are emerging: Cursor (globs), Copilot (YAML), Codex CLI (directory hierarchy), Claude Code (path-scoped rules).
5. MCP as integration layer: Standard way to extend context capabilities across tools.
6. Transparency vs. magic tradeoff: Zed/Aider prioritize explicit control. Cursor/Windsurf prioritize automatic assembly. Fundamental design philosophy split.