01 · Persistent memory
Stop explaining the same project twice.
Capture architecture decisions, conventions, constraints, and fixes once. Ctxr keeps that context organized and ready for every coding agent you use.
Build at the speed of an idea without losing context.
Ctxr turns your repository, architecture, decisions, and plans into reusable context, so every coding agent starts informed—not from zero. Spend fewer tokens re-explaining your project and more time shipping what matters.
Beta v0.5.0
Context that compounds
Everything your coding agent needs to understand the work.
Ctxr connects what your project knows, how it is built, and what should happen next—without spending another prompt rebuilding context from scratch.
02 · Codebase intelligence
See how the whole codebase fits together.
Turn your repository into a clear map of modules, dependencies, data models, and application flows—so you know where a change belongs before an agent starts editing.
03 · Agent-ready planning
Move from an idea to an implementation-ready plan.
Generate structured build plans grounded in your repository and memories. Copy the final prompt into your AI builder with risks, relevant files, and verification already included.
Built for agent-first development
One context layer for the entire build cycle.
From understanding an unfamiliar repository to handing off an implementation plan, Ctxr keeps project knowledge structured and reusable.
01
Persistent project memory
Store decisions, conventions, fixes, and constraints as durable context instead of rebuilding them in every prompt.
02
Living codebase maps
Understand modules, dependencies, data models, and application flows before asking an agent to make a change.
03
AI Project Guide
Turn an idea into a repository-aware implementation path with relevant files, risks, and verification steps.
04
Trackable build plans
Save generated plans, move work through clear statuses, and complete verification checklists as the implementation progresses.
05
GitHub-aware context
Browse connected repositories and derive context from real project structure rather than generic assumptions.
06
Context retrieval
Find the right memory across projects, then copy or export focused Markdown for the coding agent you choose.
Export context for Codex, Cursor, Claude Code, and AI website builders
Use context, not repetition
Spend tokens building—not re-explaining.
Ctxr gives each agent a focused context pack, so new sessions can continue the work without loading the full project history again.
Focused retrieval
65%
fewer context tokens
Across five illustrative coding sessions, persistent context reduces repeated input from 40k to 14k tokens.
40k
Without Ctxr
14k
With Ctxr
Capture the project once
Retrieve only relevant memories
Keep agent handoffs focused
Context tokens by session
Thousands of input tokens
Without CtxrWith Ctxr
Initial buildInitial capture
8k
8k
Feature work1.5k retrieved
8k
1.5k
New workflow1.5k retrieved
8k
1.5k
Bug fix1.5k retrieved
8k
1.5k
Agent handoff1.5k retrieved
8k
1.5k
02k4k6k8k tokens
Illustrative estimate: 8k tokens per session without reuse, versus an 8k initial capture and 1.5k focused retrieval for later sessions. Actual usage varies by project, model, task, and selected memories.
Simple pricing
Start with context. Scale when it compounds.
Every plan gives your coding agents a cleaner starting point. Upgrade when your projects—or your team—need more shared memory.
Community
$0forever
For exploring persistent context across your personal projects.
10 active projects
100 project memories
GitHub repository browser
Markdown context export
Builder
$16per month
For developers shipping regularly with multiple coding agents.
Unlimited projects
Unlimited memories
AI Project Guide
Build Plans and Codebase Maps
Priority context retrieval
Studio
$39per member / month
For small teams that need one shared source of project truth.
Everything in Builder
Shared project memory
Team roles and permissions
Centralized agent handoffs
Priority support
Prices shown in USD. Cancel or change plans at any time.
Questions, answered
Everything you need to know.
Still deciding whether Ctxr fits your workflow? These are the questions developers usually ask first.
01What does Ctxr store?
Ctxr stores the project knowledge that should survive between sessions: architecture decisions, conventions, known issues, implementation plans, and selected repository context.
02Does Ctxr replace my coding agent?
No. Ctxr is the context layer between your project and the agent you already use. Export or retrieve focused context for Codex, Cursor, Claude Code, and other AI development tools.
03How does Ctxr reduce token usage?
Instead of repeatedly sending a full project explanation, Ctxr retrieves a smaller context pack relevant to the current task. The exact savings depend on the project and what you select.
04Can I connect an existing GitHub project?
Yes. Connect a repository, browse its files, map the codebase, and add durable memories without moving your source code into a new workflow.
05Can I export my data?
Yes. Project guides, build plans, and focused context can be exported as Markdown, making your knowledge portable across agents and tools.
06Is it useful for solo developers?
That is where Ctxr starts. It helps solo builders preserve decisions across fast iterations, then provides a shared context system when more collaborators join.
07Which coding agents can I use?
Ctxr creates portable context rather than locking you into one agent. Use the exported Markdown with Codex, Cursor, Claude Code, Windsurf, or any tool that accepts project instructions.
08How is my repository context used?
Ctxr reads the repository information needed for the feature you request, such as browsing files, building a codebase map, or preparing focused context for an agent.
09How quickly can I set up a project?
Connect GitHub, choose a repository and branch, then capture the first memories that matter. Most projects can establish a useful context layer in a few minutes.
10How do memories stay current?
You control what persists. Memories can be reviewed, edited, pinned, or replaced as architecture and product decisions evolve, keeping old assumptions out of future sessions.
Give your agents a memory
Your next session should start where the last one finished.
Connect a repository, preserve what matters, and spend the next prompt moving the product forward.