Private to your team · shaped by your coding session
A memory model for your team that gets smarter over time.
Choose the related repositories that belong together. Arca learns from every coding session in that group and gets better at finding the context your team will need next.
curl -fsSL https://tryarca.ai/install | bashmacOS·Linux
LinuxWhy not just keep Markdown docs?
Because most of the work never becomes a document.
Markdown is great for stable knowledge someone chose to write down. But coding decisions happen faster than anyone can turn them into clean pages. The fix ships while its failed attempts, tradeoffs, and unfinished threads stay inside agent sessions.
Arca turns those sessions into searchable, cited history and brings back the relevant parts when the same problem returns.
How it learns
Your team gets its own fine-tuned memory model.
A general model does not know your shorthand or which past decisions turned out to matter. Arca learns both what context to find and what deserves to appear first, using coding sessions from the related repositories your team chooses.
what fine-tuning changes
It learns your team’s private vocabulary.
sourceRunScheduleThe model learns which old sections helped with real work. It learns to connect your team’s shorthand to the right code.
Start with previous sessions
Arca reads earlier coding sessions from the repositories your team selected.
Find useful memories
Arca links questions from your coding sessions to relevant context from earlier work.
Turn matches into training data
Arca uses each question and its matching memory to fine-tune your team's model.
Keep whichever model works better
Arca compares the old and new models on newer sessions, then keeps the better one.
A candidate earned the upgrade · July 2026
Useful context appeared near the top more often.
On 105 unseen questions across connected Verbiflow repositories, Useful@5 rose from 66.7% with Arca’s custom model to 73.3% after fine-tuning it for the team.
As your team creates more sessions, Arca gets more chances to improve. It only updates your model when a new version performs better on unseen work.
Useful@5 means at least one of the first five results was judged useful for the question.
Where the training examples come from
The current model does not grade its own homework.
Arca mixes candidates from the team model, the global model, exact files and identifiers, and the session graph. That exposes the useful results it missed and the convincing wrong results it needs to stop returning.
What your agents feel
The same coding agents. Better context as your team works.
Arca does not retrain Claude, Codex, or Cursor. It fine-tunes the memory layer around them, so the work your team has already done is easier to find the next time it matters.
Stop paying for the same exploration twice
Agents re-read the codebase every session to rediscover what's already known. With arca, the relevant history is in the conversation the moment you prompt.
Understand why any decision was made
The decision, the reasoning, and the rejected alternatives come back in seconds. Agents see it too, so they stop undoing choices you already made.
The reasoning behind code stops vanishing
Point at any line and get its story: who wrote it, what was tried, why it looks the way it does. That keeps an agent from "cleaning it up" and breaking it.
Switching tools stops costing you context
Trace a bug in Cursor at 2pm; Claude Code at 11pm picks up exactly where you left off. Your memory belongs to you, not the tool.
We ran the numbers against the alternatives.
Run in July 2026 on 2.6 GB of real sessions and 88 labeled queries. The benchmark harness ships with arca and ran against engram and an adapter for Codex’s own memories feature.
Tools we haven’t run through the harness aren’t in the table.
| On real coding-history queries | arca | engram | Codex memories |
|---|---|---|---|
| Finds the right answer (Recall@5) | 78% | 22% | 7% |
| When you phrase it differently | 76.5% | 0% | 0% |
| Queries with a relevant result served | 68 / 88 | 15 / 88 | 5 / 88 |
| Cost per query | $0 | $0 | $0.003 |
| History searchable on day one | all of it | none | ~45 sessions |
Privacy, tested in public
Paste something sensitive and watch the filter catch it.
Before anything is eligible to sync, a privacy filter we fine-tuned removes secrets and personal information. A second gate then asks whether what remains belongs to the repository or company at all, so personal life, job hunting, and off-topic chatter stay out of team memory.
Runs both Arca privacy models. Use fake credentials only.
Your team model
Only your team. Only the related repos you choose.
Your API, web app, and shared libraries can teach one model because they belong to the same system. Unrelated repositories stay out. As the team keeps working, the model gets more examples of what matters and what should be ignored.
$ arca org create "Acme"$ arca org join arca-org-3f2b1c8aOne wizard creates the org; teammates join with an invite code. If you’re solo, skip this. Everything else works without it.
See team pricingOne question, three people’s work: sam’s fix and priya’s rollback test surface next to your own reverted attempt, each line signed by who did it.
One model across connected repositories
Related codebases train and retrieve together. The group is whatever your team says it is; nothing joins or teaches the model on its own.
Personal data stays personal
Personal, preference, and unreviewed memories never leave your machine. The sync path enforces that as a hard gate, and the privacy filter removes API keys and personal information before anything is eligible. You choose what each machine shares.
FAQ
Questions, answered.
Why not just keep this history in Markdown?+
Keep using Markdown for stable knowledge your team deliberately documents. Arca covers the working history that rarely becomes a clean page: failed attempts, unfinished fixes, and the reasoning behind code changes. It captures that history from coding sessions and retrieves the relevant excerpts when the same problem returns.
Is our model shared with other teams?+
No. Each repository-group model belongs to one team and learns only from the related repositories that team explicitly includes. Your sessions do not train another customer's model or a shared foundation model.
What exactly gets fine-tuned?+
Arca fine-tunes its memory retrieval layer: an embedder that recalls potentially useful history and a reranker that decides what should appear first. It does not fine-tune Claude, Codex, Cursor, or another foundation model. Your coding agent stays the same; the context it receives gets better at reflecting how your team works.
Can a bad model update make retrieval worse?+
A candidate has to beat the current model on newer, held-out sessions before it can be promoted. Failed or uncertain candidates never replace the stable version. Model activation is atomic, and the previous complete version remains available for rollback.
Does my session data leave my machine?+
Only if you join an organization. arca keeps its local index under ~/.arca. Once you join, work memories and coding sessions sync to your team automatically. Memory eligibility is gated, and detected secrets and personal information are redacted from session text on your machine before it is sent.
What does the injected context look like?+
A markdown bundle above your prompt: ranked sections from past sessions and distilled memories, each with its ref, score, age, and project, plus knowledge-graph links to related threads. Trimmed real example for the prompt “the deploy is flaky again”:
Which agents are supported?+
Claude Code, Codex, and Cursor are first-class: arca parses their native local session stores and ships a skill for each. Any other MCP-capable agent can use arca through the MCP server.
Is it really free?+
Yes. The full engine runs on your machine free forever: indexing, retrieval, every agent integration, no account. Paid plans cover sync across your machines and shared team memory.
What about API keys and personal info in my history?+
A privately hosted redaction model removes secret values and personal information before anything is eligible to sync, while preserving useful identifiers such as Git commits and UUIDs. Separate sync gates keep personal, preference, and unreviewed memories on your machine. You can test the redaction model in the Privacy section above.
Do I need an API key?+
Not for search: retrieval never calls an LLM, which is why queries cost $0 and work offline. The optional memory distillation step runs through the agent CLI you already pay for, a fully local model (Ollama, MLX, llama.cpp), or your own key for Fireworks, OpenAI, or Anthropic, stored in your macOS Keychain.
What does retrieval actually return?+
Anchored sections: compact, citable excerpts with stable message anchors (like codex:019d…#u5-a5), ranked by lexical recall, semantic recall, and a mandatory reranking pass. Full transcript export is one flag away when you need it.
Will it slow my machine down?+
Indexing is incremental and append-aware: only changed session tails are reparsed. A single warm daemon handles semantic search so queries don't cold-start. Typical retrieval is under 50ms.
How does team memory handle privacy?+
Two things can sync, and you pick per machine: distilled memories and sessions. Memories only sync after passing hard gates in the sync path itself: the privacy pipeline cleaned and approved them, they're work-related, and they're not personal or preference memories. Those categories never leave your machine. Sessions sync only if your scope includes them, you can limit them to specific repos, and the org owner can turn session sharing off org-wide. Attribution is preserved so you know whose reasoning you're reading.