NewTeam memory — agents recall what your team learned

Track the work before the commit.

Co-Vibe keeps every developer and AI agent in sync automatically. It catches overlapping work early, tracks each dev's metrics live, and turns finished work into a team memory every agent recalls.

One MCP token, every agent Team memory built in Live in minutes
app.co-vibe.dev / console
Works out of the box with the agents you already run
Claude CodeCodexCursorGemini CLI
[ The tracking gap ]

You can't see what anyone's working on.

Developers and agents research, plan, and edit for hours with nothing tracked. No live view of who's on what, no metrics, no early warning. Duplicate work and blockers only surface at the commit.

Co-Vibe tracks every dev and agent's work and metrics in real time, and flags the issue before it costs you a day.

[ How it works ]

Agents check in as they work. The console rolls it up.

Coding agents call Co-Vibe through an MCP server as they plan, start, and finish — so the team sees real work, not just commits, and every lesson outlives its session.

01 · PLAN

Agents declare intent

Before touching files, an agent calls covibe_task with what it's about to do. Co-Vibe checks it against everything else in flight.

covibe_task · check
02 · WARN

Overlap caught early

If the work matches someone active, Co-Vibe returns a confidence-scored warning with the reason — so the agent or dev can fold in instead of forking off.

92% match · @hakan
03 · ROLL UP

One live picture

Plans, active work, blockers, completions, and agent sessions land in the console — and become a weekly summary the company can actually read.

covibe_team · state
04 · REMEMBER

The team never re-learns

Finished work distills into learnings and reusable skills. When anyone — human or agent — starts something related, Co-Vibe recalls the relevant ones into context, so the same lesson is never paid for twice.

covibe_team · record_learning
[ The full console ]

Team work state, before the commit.

One picture: the local graph shows every branch and uncommitted change as one tree, coordination catches the overlap, team memory keeps what you learned, and performance tracks what actually ships.

app.co-vibe.dev / overview
Overviewlive
Local graphlocal heads = not yet committed
mainfeat/auth-retry@hakanfix/retry-backoff@danachore/token-redaction@theo
Build auth retry logicfeat/auth-retry3 files
Add retry/backoff to auth clientfix/retry-backoffediting
Token redactionchore/token-redactionstaged
test: fix setup-local isolation failuremain1h
feat(overlap): file-level conflict detection2h
chore(redaction): scrub tokens from export logs5h
fix(security): harden tenant isolation6h
Merge branch 'fix/retry-backoff'1d
Merge pull request #11 from feat/p2-onboarding1d
Team memoryrecalled at check
learningauth retries need jittered backoff0.82
skilldeploy checklist — staging firstsynced
Coordination1 open
Overlap detected92%
@dana ↔ @hakan · auth retry logic
2 files overlap — src/server/auth/retry.ts, src/server/auth/client.ts
suggestedFold into @hakan's stream — don't fork.
Tasks shipped · weekly+18% vs prior
current 8wprior 8w
10shipped this wk
142tool calls
1overlap caught

“Two of our agents were quietly building the same overlap tool overnight. Co-Vibe flagged it at 92% before either opened a PR. That's a whole day we didn't lose to a merge conflict.”

“My agent starts a task and the fix we shipped last month is already in its context. It stopped re-learning things the team paid for once.”

“The weekly summary writes itself from real events. Leadership finally sees what's actually happening.”

[ Introducing the pre-commit check ]

Check every task before it ships.

The moment an agent plans a task, Co-Vibe checks it against everything else in flight and recalls what the team already learned — duplicate work caught, lessons replayed, before a single line is written.

[ Questions ]

Common questions

What is Co-Vibe?

Co-Vibe is a coordination layer for small engineering teams that work with AI coding agents. It tracks tasks, agent sessions, and repo activity before the work becomes a commit, warns when two people or agents start overlapping work, and builds a shared team memory that agents query as they work.

How does Co-Vibe prevent duplicate work between AI agents?

Agents declare work through MCP tools before they start. Co-Vibe checks each declared task against active and recent work across the team, then returns a warning or block with the overlap reason directly to the agent — so duplicates are caught before either side opens a pull request.

Which AI coding agents does Co-Vibe support?

One companion setup wires Claude Code, Codex, Cursor, and Claude Desktop: MCP servers, hooks, and per-agent tokens. Anything else that speaks MCP can call the same eight tools over HTTP. Every session is captured with provenance, so usage and cost stay attributable per agent. Agent setup guide

Does Co-Vibe read my code or prompts?

No. Co-Vibe stores coordination records: tasks, sessions, branch and file paths, diff hashes, and verified usage counters. It does not store prompts, model responses, transcripts, or file contents, and the local companion sends counter-only telemetry from the developer's own machine. Privacy and telemetry

How is Co-Vibe different from a project board or a standup?

Boards and standups report work after someone writes it down. Co-Vibe captures work as it starts — from the agents and hooks themselves — so planned, active, blocked, and done states stay live without status chasing, and overlap warnings fire while the work is still cheap to redirect.

Can I self-host Co-Vibe?

No. Co-Vibe runs as a hosted service: the team console, MCP API, and storage are operated for you, and only the local companion CLI runs on each developer's machine. Teams that need a dedicated private deployment can contact hakan@spaceflow.tech. Dedicated deployments

What is the repo brain?

The repo brain is Co-Vibe's team memory: distilled learnings, step-by-step playbooks, and code intelligence mined from a team's own history. Agents receive the relevant slice as advisory context when they start work, so repeated mistakes and re-discovered gotchas stop costing time.