Auric is the shared state and coordination layer for AI-native projects. When developers, AI agents, and tools work on the same project, they drift into different versions of its decisions, assumptions, and plans. Auric keeps one evolving Project Reality everyone works from, tracks who is doing what and what depends on what, and detects when a change makes someone else’s work stale. So Claude, Codex, Cursor, developers, and CI can work in parallel without splitting into different realities.

We started Auric after repeatedly hitting the same problem while working with AI coding tools.

The issue wasn’t just that an agent forgot an old conversation. The bigger problem appeared once multiple humans, agents, and tools started working on the same project.

Each one could be individually capable and still end up working from a different understanding of what the project currently is.

For example, one agent may still assume Redis sessions exist while another has already replaced that architecture. They may touch completely different files, so Git sees no conflict — but the project is already inconsistent.

Auric is our attempt to make the project itself persistent.

We maintain decisions, assumptions, dependencies, constraints, blockers, active work, outcomes, provenance, and history as one evolving Project Reality.

Every connected actor works against a known revision of that reality. When something important changes, Auric can determine who is affected and update the relevant understanding instead of forcing every agent to rebuild context from chats, notes, or static handoff files.

We’re also keeping deterministic project state separate from cognition. Facts, decisions, permissions, dependencies, and history stay governed and inspectable, while longer term we’re exploring persistent beliefs, uncertainty, attention, experience, and learned project models that can survive whichever LLM is being used.

The long-term idea is simple:

Humans, agents, and tools should be able to come and go while the project keeps its state, history, understanding, and continuity.

We’re building toward genuinely multiplayer AI-native projects where everyone works from the same evolving reality.

If you’re already running multiple coding agents, I’d love to know:

Where does coordination break first for you?

What stands out about Auric is its local-first approach to persistent memory for AI coding assistants. Instead of relying on probabilistic retrieval, it uses a structured, append-only operational ledger with temporal validity and causal relationships to preserve project context, architectural decisions, and unresolved tasks. I particularly like the deterministic resume workflow and the focus on keeping development sessions connected without repeatedly re-explaining the project. Automatically extracting Git state would make this workflow even more seamless. I'm also curious to see how Auric evolves to handle concurrent agents, SQLite write contention, and cross-agent state consistency. A promising approach to making AI-assisted development more reliable and context-aware!

I'd love to see automatic Git state extraction, smoother onboarding, and clearer visibility into memory synchronization and persistence status. Better support for concurrent AI agents, including reliable state reconciliation and SQLite write contention handling, would also make Auric more robust as projects scale. More diagnostics and end-to-end verification tools would help developers trust the saved project state.

I was looking for a reliable way to maintain project context across AI-assisted coding sessions. Traditional notes and manually maintained task lists can lose track of important technical decisions and implementation details. Auric's structured, local-first approach makes it an interesting alternative for keeping development work organized and continuous.