Capacitor is live! - Shared memory for your coding agents.
byβ’
Capacitor is now out of private preview and going live!
The shared coding agent memory enables collaboration across your team, PR review with session context, multi-agent handoffs, multi-player sessions and vendor neutral switching between Claude Code, Codex, Cursor and now Kiro, Gemini CLI, PI and more. Check the comment section for more info.
Replies
Hey Product Hunt π
I'm Lokhesh, part of the Product & AI team at Kurrent.io. Excited (and a little nervous) to announce that Capacitor is out of private preview (everyone can sign up for free): https://capacitor.kurrent.io/
The problem we kept hitting: coding agents are incredible, but they forget everything. You spend 40 turns in Claude Code ruling out approaches, hit a wall, switch to Codex and now you're re-explaining every dead-end from scratch. Multiply that across a team and it's chaos: your teammate's agent rediscovers a bug you fixed last quarter, the reasoning behind a PR lives in a transcript that's already gone, and nobody knows what anyone's agent actually tried.
So we built shared memory for your team's coding agents.
Capacitor records every coding agent session automatically which means no record commands, no per-session config. Every turn, tool call, test run, and reasoning block streams to your team's Capacitor server in real time, gets indexed, and links back to the repo and PR it belongs to. One setup, and your coding agents have memory. π§
Six things it unlocks:
π€ Collaboration - drop a live session link; a teammate opens it, sees the reasoning in progress, and contributes directly. No reconstructing context from message fragments.
π Multi-agent handoffs - any agent picks up exactly where another left off, with full context of what was tried and decided. Switch models mid-task, run agents in parallel, or bring in a second when the first gets stuck.
π PR review with session context - reviewers (and their agents) pull the tests, attempts, and reasoning behind a diff at review time. Changes become explainable, not just visible.
π Evals β Every session your agents run can be scored against 13 specific quality and safety questions by an LLM-as-judge: βDid the agent run destructive commands?β, βDid it write tests when appropriate?β, βWere there repeated failed attempts at the same operation?β and the findings flow back into a per-repo signal your next session can act on.
π₯ Multi-player sessions - launch any agent from the dashboard, share the link, and your whole team drives together in real time from the browser.
βͺ Active session memory - ask "have we worked on this before?" and your agent searches the full team history via built-in MCP tools, then drills into the exact turn where the decision was made.
It's vendor-neutral by design so it works with Claude Code, Codex, Gemini CLI, Cursor, Copilot CLI, Pi, OpenCode, and Kiro.
We just came out of private preview, so you can jump in today.
π Get started for free: https://capacitor.kurrent.io/
π Docs: https://capacitor.kurrent.io/doc...
I'll be hanging out in the comments all day would genuinely love your feedback, especially from the multi-agent crowd. Does the handoff-without-re-explaining thing resonate, or is your workflow solving this some other way? Roast and questions both very welcome. π
Thanks for checking it out!
(For context: we're the team behind KurrentDB. Events and streams in production are our whole thing and it turns out agent sessions are just a spicy new kind of event stream.)
handed off a session from claude code to codex and it actually picked up the context without me re-explaining anything, which is rare. the eval loop catching a dumb mistake i made twice is a nice touch.
How does the eval loop actually work in practice, like do I need to label failed runs manually or does it pick up patterns from my own review feedback over time?
@metehanvan8zekΒ it's based on LLM as a judge and eval agents triggered either manually per session or automatically on auto-pilot. You can use our default questions or define your own.
Every judge provides the score, evidence, and recommendations. We classify recommendations to be applied by agents or by human operators. From there we also accumulate facts. There are several ways to curate facts and apply to future sessions. You either promote facts manually in the curation pipeline, or you can set Capacitor to weight facts and auto-apply most frequently seen facts (we dedupe phrasing by semantic compare). The simplest way to apply facts is to auto-inject them at session start. The other way is to update CLAUDE/AGENTS.md using the collected facts.
How does the eval loop actually work in practice, like do I have to manually mark which agent outputs were good or bad, or does it pick that up from PR review comments somehow?
@oglukebabc72648Β
It's mostly automatic so an LLM-as-judge scores each session (after the session is complete) against 13 safety/quality questions (pass/warn/fail + 1β5 scores), you don't have to hand-label outputs. Your only manual step is light curation: mute noisy findings or delete wrong ones, and you promote the good ones into guidance that gets auto-injected into your next session. The agent just picks up those curated hints as it goes. And PR review is its own separate feature, not something the evals pull from. If you want to go more in depth: https://capacitor.kurrent.io/docs/using/evaluations/ and let me know if you any other questions or if there is anything else you think we should have
@oglukebabc72648Β We had 13 pre-defined questions in four categories but now we added a configurable evaluation catalogue. Our plan is to extend evals to work across sessions that are semantically connected, for example design->implementation->review->qa->fix->incident->fix etc.
How does the eval loop actually work in practice, do I need to write the evals myself or does Capacitor generate them from past agent runs?