Your team.
One shared AI context.

Connect your team’s AI sessions so decisions, discoveries and next steps stay with the project.

Get started

See how it works

SSam · Claude CodeLive

Should rate limits count per instance or globally?

Globally. Keep the counters in Postgres so every instance shares one count.

Open question: fixed window, or sliding log?

Shared project contextapi

Decision: Rate limits count globally; counters live in Postgres. Sam · msg 412
Open question: Fixed window or sliding log? msg 418
Next step: Test a shorter window under burst traffic.

SDP3 teammates

DDana · CodexLive

Picked up from the shared context: counters live in Postgres, limits count globally. Starting on the open question.

Run the burst test with a 10s window.

Demo · names and sessions are illustrative

A demo with made-up names: Sam decides how API rate limits should work in Claude Code, the decision joins the project’s shared context, and Dana resumes in Codex with it already in hand.

Independent sessions

A session in Claude Code or Codex holds more than code: why an approach was chosen, what failed, what still needs checking.

On its own, each session stays on one laptop. A teammate can pull the branch, but still has to ask what happened.

Work. Share. Pick up.

Step 01 of 03

A session reaches a decision

Sam works in Claude Code as usual. The session holds a decision and a question nobody has answered yet.

Session · Sam · Claude Code · feat/limits

Should rate limits count per instance or globally?

Globally. Each serverless instance would otherwise keep its own count, so the counters should live in Postgres. msg 412

And the window?

Fixed window is simpler; a sliding log is fairer at the boundary. I have not decided. msg 418

Only yousynced 2m ago · 14 messages

One example, start to finish. The step buttons always work; on a wide screen, scrolling through this section advances them too.

Shared context

Every shared session lands in the project’s context, grouped by repository, with its decisions and open questions still attached to the session they came from.

How claims are sourced

Each claim in a brief cites the message or commit behind it, resolved against the session record. A claim that resolves to nothing is labelled an inference rather than dropped. That gives traceability, not correctness.

Decisions retained

As sessions come and go, the decisions stay. A teammate who picks the work up next week starts from the same record, not from a chat history.

Where the work opens

Resuming opens a separate worktree at the recorded commit, so your own checkout is untouched. Uncommitted files travel in the snapshot. Briefs are written on your machine through your own Claude or Codex login; Anva never holds a model key.

Private until you decide otherwise

A session arrives as yours alone. Share a repository, share one session, or hand it to one person. Each is a separate decision.

Scope and invitations

Only folders you add to a machine’s scope are read at all, and an empty scope uploads nothing. Recognized secrets are stripped before upload. Joining is by invitation addressed to one GitHub username or one email address; it expires after seven days and the sender can withdraw it.

Rate limiting for the public API Only you

Who can read it

The default for every session that syncs. Nobody else can see that it exists.

What the next person gets

Without Anva

Dana gets the branch

git log --oneline -3

4b6df71 wip limits
9c1e02a counters
1a7f3d0 scaffold

Why Postgres? Ask Sam.
Was the window decided? Ask Sam.
Uncommitted files stayed on Sam’s laptop.

With Anva

Dana gets the context, the code and the next step

Decision: Counters live in Postgres; limits count globally. msg 412
Open question: Fixed window or sliding log? msg 418
Next step: Test a shorter window under burst traffic.
Code: 4b6df71 in a separate worktree, 3 uncommitted files restored.

A handoff carries the reasoning and the code together, so picking up work does not start with asking what happened.

Keep the context.
Keep moving.

Create a workspace with GitHub, link a machine, and invite the people you work with.