Tandem

Tandem
Tandem Dashboard Overview
Tandem Dashboard Live Graph

Inspiration

AI assistants are powerful individually, but they are still difficult to use as a team. One teammate may work with Claude, another with ChatGPT, and another with Gemini. Each assistant develops useful context, but that knowledge stays trapped in separate conversations. Decisions get repeated, files drift apart, and assistants can unknowingly contradict or overwrite each other.

We experienced this problem ourselves. The limitation was not the intelligence of any individual model; it was the lack of shared infrastructure around them.

That inspired Tandem: a shared workspace where people and their preferred AI assistants can work from the same files, project context, and history.

What it does

Tandem gives a team one source of truth without forcing everyone to adopt the same assistant.

Through MCP, assistants can securely connect to a workspace, read relevant context, update canonical documents, publish findings, and coordinate tasks. People use a web dashboard to edit files, review history, see what each assistant has done, and correct the project’s shared understanding.

Tandem also includes an event-driven background context manager. It observes meaningful workspace activity, such as MCP tool calls, document changes, test results, and optional Claude Code activity hooks, and uses Claude Haiku to turn that stream into compact, structured context. It identifies work in progress, completed tasks, blockers, findings, decisions, and possible conflicts between teammates or assistants.

Each observation includes its evidence, confidence, sources, and revision history. Tandem distinguishes between something an assistant merely claimed and something supported by a successful test or other evidence, helping the team understand what is actually complete.

The Live dashboard shows assistant activity as it happens, which context version each assistant has received, and which assistants may be behind. It shows “last MCP action” and “last sync,” never a misleading “online” status.

How we built it

We built Tandem with Next.js, React, Convex, MCP, and Claude Haiku.

Convex serves as the shared backend for both the human dashboard and connected assistants. We use several Convex features together:

Reactive queries update the dashboard when an assistant saves a file, synchronizes context, or records new activity.
Scheduled functions and actions power the background context manager. Significant events schedule a batch, and Convex handles leases, retries, and backoff while Haiku extracts and compacts useful context.
Convex database transactions keep document versions, attribution, activity events, and revision history consistent.
Convex Auth secures the dashboard and enforces workspace membership.
Convex file storage and HTTP actions provide protected uploads and previews for PDFs and images.
The @convex-dev/mcp component lets our MCP server and OAuth flow run directly inside the Convex deployment instead of requiring a separate server.

Every assistant connection belongs to one person and one workspace. As a result, Tandem can show not only that an agent changed something, but whose assistant made the change and through which client.

We also built optimistic version checks into files, tasks, folders, and context. If someone edits stale information, Tandem rejects the write and shows the newer work instead of silently overwriting it. Previous revisions remain available, and restoring one creates a new revision rather than erasing history.

Challenges we ran into

Our biggest challenge was coordinating assistants that run inside products we do not control. MCP allows an assistant to use Tandem’s tools, but Tandem cannot wake a native chat when something changes. We designed around this honestly: assistants synchronize when they next act, while Tandem tracks which shared context they have received.

Another challenge was separating useful signals from noise. Saving every tool call or conversation would create an unreadable history and introduce privacy concerns. Our context manager therefore processes bounded, redacted activity and document evidence rather than exporting private chat histories.

We also had to handle unreliable claims. An assistant saying “the tests pass” is different from Tandem observing a successful test command. Our evidence levels preserve that distinction.

Finally, multiple contributors can act on the same information simultaneously. We addressed this with explicit version conflicts, immutable revision history, and context-level detection of overlapping or contradictory work.

What we learned

We learned that shared memory is not enough. Effective AI collaboration requires provenance, synchronization, evidence, conflict handling, and a clear boundary between what the system observed and what the team accepts as true.

We also learned that AI is most useful when it strengthens human teamwork. Tandem does not replace the people coordinating a project; it helps them understand what their assistants are doing and gives everyone a common place to work.

What’s next

We want to support more MCP-compatible clients, improve conflict detection, and make Tandem useful for longer-running projects across engineering, research, design, and other collaborative work.

Our long-term vision is to let every teammate choose the assistant that works best for them while keeping the entire team, human and AI, in sync.