Context Sharing Between Coding Agents: How Claude Code, Codex, and Antigravity Share One Project Memory with Taskive

If you work with AI coding agents, you know the morning ritual: re-explain the repo, re-state last week's architecture decision, re-discover the gotcha that burned you on Tuesday. Agents are brilliant inside a session and amnesiac between them — and the problem compounds when your team uses more than one agent. The decision Claude Code made yesterday is invisible to the Codex session running today.

The fix isn't a bigger context window. It's a shared, durable, project-scoped memory that every agent reads at the start of a session and writes to at the end. That's what Taskive's built-in MCP server provides.

The problem: N agents, N silos

A typical team in 2026 might run Claude Code in the terminal, Codex for spikes and reviews, and an ambient agent like Antigravity watching the sprint. Each one maintains its own notion of context:

• Claude Code has its CLAUDE.md and session transcripts
• Codex has its own instructions file and history
• Whatever the third tool is, it has a third thing

None of them read each other's notes. Worse, none of them share context with the humans on the team. The knowledge generated inside an AI session — why an approach was rejected, which branch holds the spike, what's blocked on what — evaporates when the terminal closes.

The fix: one knowledge base, spoken over MCP

Taskive exposes its project knowledge base as an MCP (Model Context Protocol) server. Any MCP-capable agent — Claude Code, Codex, Cursor, Antigravity — connects with a scoped token and gets the same set of tools:

Reading context at session start:

• get_project_memory — the distilled project state: recent decisions, active briefs, and team-visible notes, ready to inject into a fresh session
• get_project_briefs — living project briefs that describe what the project is, kept current instead of rotting in a wiki
• search_context — semantic search across every entry, so an agent can ask "what did we decide about WebSockets?" and get the actual decision back
• get_start_task_context — everything relevant to one specific task before an agent starts it

Writing context at session end:

• save_session_summary — a private end-of-session handoff note (what was done, what's next, what to watch out for)
• log_decision — a structured decision record: the context, the rationale, the outcome. This is the entry your future agents will thank you for
• write_context — free-form notes, briefs, and knowledge entries with explicit visibility

Install is one command in your repo:

npx taskive-kit install

The kit wires up the MCP connection for Claude Code, Codex, and other supported agents, so every session in that repo automatically has the tools above.

What cross-agent context sharing looks like in practice

Here's a real shape of a working week:

Monday — Claude Code implements a polling fallback for a notification system. Before the session ends, it logs a decision: "Defer WebSockets to Q4 — ship v1 on 15s polling", with the rationale (no WebSocket infra yet; Postgres LISTEN/NOTIFY is incompatible with PgBouncer transaction pooling) and the outcome (revisit past 500 concurrent users). It also saves a session summary flagging the read-receipts endpoint as the next step.

Wednesday — Codex picks up a billing spike. At session start it pulls project memory and already knows about the polling decision — no human had to relay it. At session end it writes its own handoff: Stripe Checkout beats Payment Links, the skeleton lives on spike/stripe-checkout, and there's a blocker on the entitlements schema.

Friday — a teammate (human, no agent involved) opens the project's Knowledge tab in Taskive and reads all of it: each entry tagged with its source — via claude-code, via codex — with timestamps and visibility labels. The AI sessions produced team knowledge, not terminal ghosts.

Every entry carries agent attribution, so you always know which tool wrote what. Attribution is advisory metadata for humans — access control comes from the authenticated token, not the label.

Visibility: private notes vs. team knowledge

Not everything an agent writes should be broadcast. Taskive's knowledge entries have three visibility levels:

• Private — session summaries default here. They're personal working notes, encrypted at rest, visible only to the author. Other team members see that an entry exists, never its contents.
• Team — decisions and handoff notes usually live here. This is what get_project_memory serves to the next session.
• Org — knowledge worth surfacing beyond one project team.

This split matters more than it looks: it means agents can be chatty in their private summaries (dead ends, half-formed hunches) without polluting the team's shared memory, while decisions and briefs stay curated and high-signal.

Why this beats stuffing everything into CLAUDE.md

A repo instructions file is great for stable conventions — build commands, code style, architecture constants. It's the wrong tool for evolving context:

1. It doesn't scale across agents. Each tool has its own file format; you end up maintaining three copies that drift.
2. It has no time axis. A knowledge base records when a decision was made and what superseded it. Taskive entries support explicit supersedence, so outdated decisions are retired, not silently contradicted.
3. It's not queryable. Semantic search over hundreds of entries beats a 400-line markdown file that every session must swallow whole.
4. Humans don't read it. Your PM will never open CLAUDE.md. They will open the Knowledge tab.

Use both: instructions files for the constants, the shared knowledge base for everything that moves.

Getting started

1. Sign up at taskive.com and create a project (everything is unlocked during beta)
2. Run npx taskive-kit install in your repo and connect your agents
3. End your next Claude Code session with "save a session summary to Taskive" — then start a Codex session and ask it what happened

The first time an agent answers a question using another agent's notes, the morning ritual is over.

---

Taskive is an AI-augmented project management tool for software teams: Kanban, sprints, ambient risk scoring, burnout signals — and a built-in MCP server so your coding agents keep persistent project context. Free during beta at taskive.com.