Claude✓ approves
Sound approach. Use SET NX with the TTL so check-and-claim is atomic, and only process when the set succeeds. Acknowledge duplicates with a 200 so retries stop.
Ask once. Hear every model. See where they disagree.
One question goes to Claude, ChatGPT, Gemini and Grok at the same time. Bring your own API keys: you pay providers directly, at their rates, with no markup.
Early access in cohorts · no card
The product, running
One question. Three answers. The disagreement, on top.
A replay of one Consult turn, exactly as the app shows it. Flip between each model's answer and Concord's, or open the lens to read the whole thread as one model.
tRPC or REST for a new Next.js app
New Next.js product, three web engineers, a native mobile client planned for next year. tRPC for the API layer, or REST with an OpenAPI contract?
Waiting for 3 responses…
Go with REST and an OpenAPI contract. Your mobile client won't speak tRPC, so make the spec the source of truth from day one and generate a typed TypeScript client for the web app from it. The web team keeps nearly all of its end-to-end type safety, and every client you add later reads the same contract instead of a procedure-shaped adapter you'd have to version.
Two of three recommend REST with an OpenAPI contract, because the planned mobile client can't consume tRPC types directly. All three agree the web team keeps end-to-end type safety either way. The disagreement is about timing.
✓Agreement 3 of 3
The planned mobile client is the constraint that decides this.
Type safety for the web client is achievable with either approach.
One schema should be the source of truth, whichever you pick.
⟋Divergence 1 point
ChatGPT
Start with tRPC for speed; add an OpenAPI adapter when mobile arrives.
Claude
An adapter leaks procedure-shaped endpoints into a public API you then have to version.
Gemini
Agrees with Claude: make the spec the source of truth from the start.
Recommendation
Go spec-first: OpenAPI as the contract, a generated TypeScript client for web. Revisit tRPC only if mobile leaves the roadmap.
Claude
ChatGPT
Gemini
Grok+
Ask anything. Consult multiple models.
No hooks
Consult →
REST with an OpenAPI contract. tRPC's type safety is excellent while every client is TypeScript, but your mobile client won't be. Write the spec first, generate the TypeScript client from it, and the web team keeps most of the ergonomics. The cost is some ceremony up front; the payoff is one contract every client can read.
tRPC now. With three engineers and one client, iteration speed matters more than a contract nobody else consumes yet. When mobile arrives, expose the procedures you need through an OpenAPI adapter instead of rewriting the layer. Designing for a client that is a year away is how small teams slow down.
REST with OpenAPI. The mobile client is the deciding constraint: an adapter over tRPC works, but it tends to leak procedure-shaped endpoints into a public API you then have to version. Generate the web client from the spec so type safety isn't lost. Make the spec the source of truth, not an afterthought.
Scripted replay of an example session. Figures are illustrative.
The problem
You're already doing this by hand.
You ask one model and don't quite trust the answer. You paste the question into a second tab, then a third, re-explaining the context each time, and do the comparison in your head. Concord does the asking in parallel and the comparing in the open.
How it works
Three steps, one thread.
01CONSULT
Ask once. Pick which providers join this turn; the rest of the thread keeps its context.
02Compare
See where they agree and where they don't. Switch the lens to re-read the thread through any one model.
03CONCLUDE
Act on the recommendation, export the thread as a write-up or the full transcript, or share a read-only link.
One disagreement that mattered
Example session
Two models approved the plan. One found the bug.
Adding idempotency to our payment webhook handler: dedupe on the provider's event ID in Redis with a 24h TTL, then process. Anything here that breaks in production?
ChatGPT✓ approves
Agreed: atomic claim, 24h TTL. Return fast and hand the work to a queue, so slow processing doesn't trigger retries in the first place.
Gemini⟋ flags risk
Two failure modes. Providers can retry for days, so a 24h TTL lets late retries through. And under memory pressure Redis can evict keys before they expire: a double charge with no error anywhere. Put a unique constraint on event_id in the database.
The workbench
Built to be kept open all day.
The comparison is the start. These are the parts that make it a tool.
The lens
Re-read the entire conversation as Concord's synthesis, or as if only one provider had been asked. A view, not a filter: nothing in the thread is lost.
Prompt Hooks
Reusable instructions added before or after your prompt automatically, for every provider or just some.
State your assumptions before your answer.
ClaudeChatGPT
Sharpen In progress
Tighten a rough prompt before it's sent. You review the change first.
is redis ok for webhook dedupe
Is Redis with a 24h TTL safe as the only dedupe store for payment webhooks? Consider retry windows and eviction.
UseKeep mine
Workflows
Repeatable consultation pipelines, built on a canvas, with checkpoints where you step in, run inside the thread.
Draft plan→
Critique ×3→
You review→
Merge
Write-up export
Turn a thread into a composed report, or export the full transcript, as a PDF.
API contract: decision record
Write-upTranscript
Share a thread
Send a read-only link to anyone, no account needed. They can switch between every model's answer; your costs and hooks stay private.
Copy
Shows the thread as of when you shared it.
Cost, in the open
Tokens and dollars for every turn, per provider. It's your key, so it's your number.
claude-opus-52,140 tok$0.041
gpt-6-astra1,960 tok$0.028
gemini-3.8-flash1,880 tok$0.025
This turn$0.094
Ghost mode
Ask something you'd rather not keep. Ghost conversations never land in your history and can't be shared.
👻 Ghost mode
Not saved to Conferences
Any endpoint In progress
First-party providers today. Next: any OpenAI-compatible endpoint, whether self-hosted, a gateway or local.
Anthropic✓
OpenAI · Google · xAI✓
https://llm.internal/v1
Bring your own keys
Your keys. Their rates.
You connect your own provider API keys. Requests go to each provider at their standard pricing, and they bill you directly. Concord never adds a markup to tokens.
No markup on any token, from any provider.
Keys are encrypted at rest and never shown back to you, or anyone, after you save them.
Remove a key and Concord stops using it immediately.
YouOne question
→
ConcordSends with your keys, compares the answers
→
Providers
Anthropic
OpenAI
Google
xAI
Token billingProviders→you, directly, at standard rates
Concord billinga flat plan price, never per token
For your agents
In progressA second opinion before your agent commits.
We're building an MCP server so a coding agent can call Concord mid-task, get a multi-model review of its plan, and see where the models disagree before it writes the code. Not available yet.
Join the waitlist to hear when it ships →mcp.jsonillustrative · interface not final
{
"mcpServers": {
"concord": {
"url": "https://mcp.concord-ai.dev",
"headers": { "Authorization": "Bearer cnc_…" }
}
}
}
// agent → concord.consult(plan, ["claude","gpt","gemini"])
// ← consensus, divergences, recommendation
What you walk away with
Bring a question. Leave with an artifact.
Architecture review
A decision write-up
The options, what every model agreed on, and the call you made.
PR second opinion
Flagged risks
What the models raised, with the catch only one of them made kept visible.
Migration plan
A risk list, with the splits
Each risk marked where the models disagreed, so you know what to test first.
Library choice
A trade-off table
Which option survives production, and which model weighted which cost.
Why this exists
I kept doing the same thing: ask one model, not quite trust it, paste the question into another, and compare the answers in my head. The useful part was never any single answer. It was where they disagreed. Concord is the tool I wanted for that.
The Convention
Changelog, updated as we ship
Oct 16, 2026
Share links
Send a read-only snapshot of any conversation to anyone, no account needed.
Oct 15, 2026
Sign in with Google
One click in, alongside email sign-up with a verification code.
Sep 30, 2026
Workflows
Build multi-step consultation pipelines on a canvas and run them inside the thread.
Sep 26, 2026
The lens
Re-read a whole thread as if only one model had been asked, prompt hooks included.
Pricing
Every plan: your keys, no markup.
You pay providers for tokens. You pay us for the workbench.
Free
$0/ month
For trying it on real questions.
- Two providers per turn
- Synthesis and the lens
- Per-turn cost view
Pro
$19/ month
For daily use.
- Every provider
- Prompt Hooks
- Write-up export and share links
Max
$39/ month
For repeatable, automated work.
- Everything in Pro
- Workflows
- Agent access In progress
Planned pricing. Not final.
Questions
Asked plainly, answered plainly.
What is Concord?
A workbench for asking several AI models the same question at once. Concord sends your question to the providers you pick, then shows where their answers agree, where they don't, and a recommendation. You can re-read any thread through one model with the lens.
How is this different from opening several chat tabs?
Tabs make you do the work: paste the question and context into each one, read everything, and compare in your head. Concord asks in parallel, keeps one shared thread, and puts the agreements and disagreements side by side so you don't miss the one model that caught something.
What does bring-your-own-keys mean, and what will it cost me?
You add your own API keys from Anthropic, OpenAI, Google and xAI. Providers bill you directly at their standard rates, and Concord never adds a markup to tokens. Every turn shows its cost, per provider. Concord's own plans will be a flat price for the workbench.
Are my keys safe?
Keys are encrypted at rest and never displayed again after you save them, to you or anyone else. They're used only to send the requests you make. You can remove a key at any time and Concord stops using it immediately.
Does it eliminate hallucinations?
No. Several models can be confidently wrong together. What Concord does is make disagreement visible, which is often the clearest signal that something needs checking. Treat agreement as evidence, not proof.
What is the lens?
A way of re-reading the whole conversation. Concord shows its synthesis; picking a provider shows the thread as if only that model had been consulted. It changes the view, never the history. Inside any turn you can also flip between each model's answer, or compare two side by side.
Do I need a ChatGPT, Claude or Gemini subscription?
No. You need an API key from each provider you want to use. API access is separate from chat subscriptions like ChatGPT Plus or Claude Pro, and is billed per use by the provider.
Stop comparing models by hand.
Together, by design.
Early access in cohorts · no card