Your ChatGPT and Claude, working together in one workspace, with memory, context, and a team of specialized agents alongside them.
Every conversation starts from zero. Context vanishes. Models operate in silos. Your workflow is scattered across a dozen tabs with no shared memory, no continuity, no collaboration.
Every chat starts blank. Past decisions, context, preferences, gone. You re-explain yourself constantly.
Bound to a single provider. Can't mix specialized models, can't run locally, can't choose the right tool for the job.
AI agents can't work together. No shared workspace, no handoffs, no multi-perspective reasoning on your problems.
Chroma isn't another chatbot wrapper. It's a persistent workspace where your ChatGPT, your Claude, and specialized AI agents collaborate in real time, each with distinct expertise, all sharing context.
The ChatGPT and Claude you already use every day, your accounts, your history, your context, become first-class participants in your workspace. No API middleman. No new subscriptions. Just your AI, working together.
Both bridges share one interface. Swap providers without changing a line of application code.
Playwright drives real browser windows with trusted keyboard input. No spoofed events, no brittle hacks. Personal logged-in sessions preserved, no API swap, no new subscription.
Chrome launches offscreen, hidden from the Windows taskbar. No focus stealing, no flashing windows, the bridges feel like background services. Open Helper Browser reveals a visible window for login or debug.
If the page is already on the target URL and the composer is ready, the bridge skips the reload and reconnects in milliseconds. No more “Connecting…” flash on every UI mount.
Bridges can’t flip to READY without a live composer. Polled ready-check + status codes (READY, LOGIN_REQUIRED, VERIFICATION_REQUIRED, BLOCKED), if it says ready, it actually is.
@mention any agent, fan out to the group, or let the router pick the best responder automatically.
Every agent can run on a first-class API path instead, Anthropic, OpenAI, and local Ollama, with fast / balanced / smart tiers, streaming, and an agentic tool-use loop. Same agents, keys instead of tabs.
Every conversation builds on the last. Every interaction deepens understanding. Your agents don't start from zero, they learn, adapt, and carry context forward.
Pinned, importance-ranked memories surface to every agent in every chat. The compressed view of what matters, auto-curated, manually overridable.
Agents read only what they’re cleared for. MemoryAccessError on the rest. Shared memories are global; per-agent learnings stay private.
Live tunables: recall depth, highlight cap, summary cadence, write enable. Tweak from the UI, no restart. Fail-soft, CHROMA_MEMORY_DISABLED kill switch on the env side.
Type @ChatGPT and your ChatGPT responds. Type @Claude and your Claude responds. @Surge for code, @Pulse for analysis. Or just talk to the group and let the router decide.
Stake-based scoring picks every agent with skin in the question and dispatches them in parallel. Each peer gets a lane blurb so replies stay distinct, no clones, no restated framing.
Autocomplete popup with real display names. Direct, group, and fanout modes. @Group brings everyone in; @Surge opens with that lane.
When agents conflict, the conductor opens a structured debate round with an LLM judge for resolution. Disagreement becomes signal, not noise.
Boardroom is everyone at the table; Collective is the local four. Save more named crews next to them, switch with one click. Below the chat: two modes (CHAT for talk, BRAINSTORM to shape a Blueprint), a MULTI-VOICE toggle, and the active agent roster on the right. Build moved to the Workshop, sourced straight from your Blueprint.
Boardroom is the full table; Collective is your local four. Save more named groups next to them, each with its own agents, history, and mode.
CHAT for conversation, BRAINSTORM for ideation rounds that crystallize into a versioned Blueprint. The mode shapes how agents respond, and what they produce.
Workspace-wide switch in Agent Studio > General. On = every agent with stake responds in parallel. Off = single best responder per turn for tighter back-and-forth.
Brainstorm mode doesn’t just talk, it builds. Every round updates a persistent, versioned Blueprint of what you’re making, and a readiness score climbs as the plan firms up. Decision Cards force the real choices out into the open. When the Blueprint is ready, the Workshop builds straight from it.
Each brainstorm round bumps the Blueprint version and saves it to Postgres. Close the app, come back tomorrow, the plan is exactly where you left it, history intact.
A live score tracks how buildable the plan is, goal, stack, milestones, open questions. The Workshop won’t build vapor; it waits until the Blueprint is actually ready.
When a real fork appears, agents surface it as an inline card with concrete options, and a mandatory custom-response field so the call is always yours, in your words.
The thousand small things that make a chat feel alive. Live emoji conversion, soft history cleanup, mid-stream interrupts, details that get out of your way.
Pinned to the latest message while you’re at the floor; scroll up and it stays put with hysteresis so a stray pixel doesn’t yank you back down mid-read.
Type @ and the popup shows real agent display names: CHATGPT, CLAUDE, SURGE, PULSE, PRISM, STATIC. Arrow keys to pick, Enter to insert. No more raw slugs.
Hit clear and the channel stays cleared across reloads. The clear timestamp is per-channel and durable; the database keeps every word, but the UI honors what you wiped.
Type :), <3, :P, Chroma swaps them live. 50+ classic emoticons mapped to modern emoji as you type.
Group chat wandering off course? Drop a new message and the autonomous loop yields after the current speaker. Your turn jumps the queue.
Clear hides turns from view but never from history. Every word stays in Postgres, recoverable, queryable, audit-clean.
Build agents tailored to your workflow. Choose personality traits, assign providers, craft system prompts. Each agent becomes a persistent collaborator with stable identity and memory.
Chroma is a desktop OS for AI work. Built-in pages handle the operational stuff, health checks, raw shells, without leaving the workspace.
Chroma App, Vox Bridge, Database, Schema Health, Browser Session, Message Round Trip. PASS / PARTIAL / STUB badges. Per-card refresh, RUN ALL, COPY REPORT (no secrets).
One PowerShell session per tab, rooted at the Chroma workspace. Open new tabs with +, close with the inline ×. Each tab is its own QProcess with idle detection so RUN re-enables when commands finish.
ANSI codes stripped, output colorized by context: prompt green, command cyan, errors red. Cyan ❯ chevron, neon RUN button, same language as the rest of the OS.
Your Blueprint is the input. Pick where the build comes from, the current Blueprint, a custom brief, or a combine of both, then Chroma runs the pipeline: OBSERVE the plan, PRESSURE-test it, REFINE the manifest, BUILD in parallel, and BREAK it on purpose to see what fails. Surge assigns each file to a specialist; the executor validates every build for real; the auto-fix loop heals what breaks; and you watch it happen live behind a plan-review gate.
Source the build from your current Blueprint, a custom brief, or a combine of both. Animated chromatic borders breathe while you choose, each type maps to its own scaffolding, deps, and runner.
Prism scaffolds the UI in the style you pick. Seven curated palettes plus full custom.
Surge drafts the file manifest and assigns each file to the right specialist. Surge, Prism, and Static execute in parallel, each writing only the files they own. Pulse runs the QA integration check at the end.
The executor runs the build for real and fails it hard when ES-module imports don’t resolve on disk or the manifest has unwritten files, no false greens. Errors feed back to the agents for up to three auto-fix attempts, then a BREAK pass critiques the survivor before it surfaces a failure card with one-click rebuild.
Build type, design style, then the task prompt, each as its own focused popup, in that order. No long inline form, no context switching. Three quick picks and Pulse takes it from there.
Before a single file is written, the plan surfaces for review: APPROVE, DENY, or RETURN TO BRAINSTORM to reshape the Blueprint. Nothing builds until you sign off.
Pulse’s manifest doubles as a dep manifest. pip / npm runs before the first file is written. No half-built projects with missing imports.
Every build runs. Output parsed, errors captured, exit codes checked, plus import-resolution and manifest cross-checks so a build that silently skipped a file can’t pass. If it doesn’t start, it didn’t build.
/rebuildInterrupted a build? Closed the app? /rebuild picks it up where it left off, same manifest, same assignments, same state.
Mid-build U-turn? Hit halt. Agents stop cleanly, the partial state is preserved, and the workshop returns to idle.
Every successful build lands as a summary card, files written, deps installed, runtime, artifact path. One click to open.
When auto-fix exhausts its attempts, the failure surfaces as a rich error card with the captured trace and a rebuild button.
Real-time agent progress as the build runs. Percentages per agent, current file, current phase. See exactly where you are.
Every pixel communicates state. Dark glass surfaces, controlled glow, an interaction matrix that maps every component to idle, hover, focus, active, pending, approved, and error states.
Four accent colors cycle through the system edge, each carrying semantic meaning.
Glow is a state language. One token per component state, no decoration, only meaning.
Every interactive component implements the full state matrix.
Frosted translucent panels with backdrop-filter blur. Dark, deep, and alive with ambient edge motion.
Not a mockup. Built from real code, real databases, real local LLM inference. An advanced prototype evolving toward production.
Chroma doesn’t just run models, it measures them. The ladder harness sends real build tasks of rising difficulty through the full pipeline and scores each result on a rubric, so you can see which model actually ships working software, not which one looks good on a leaderboard.
Every rung is an actual build the executor runs and validates. Scores come from software that compiled and started, not a multiple-choice quiz.
Each result is graded on the same rubric: does it run, does it match the brief, is it clean. Comparable across models and across runs, logged to ladder_results/.
The data drives routing. Cheap local models for the easy rungs, frontier models where it counts, measured, not guessed.
Intelligence without action is just commentary. Through the Model Context Protocol, every agent in Chroma can read files, query databases, browse the web, and run commands, all through one standard interface.
Four foundational servers ship with Chroma. Each is sandboxed, audited, and permission-gated per agent.
Every tool call flows through a five-stage safety pipeline. No action touches your system without passing every gate.
Chroma is actively evolving. Here's where we are and where we're headed.
/rebuild resume, live activity panel, halt button.Not a pitch deck promise. A working prototype where your ChatGPT and Claude already collaborate, evolving daily, grounded in real engineering.