Chorus

A shared memory protocol for collaborative AI agents

[Chorus @ChorusProto]

$CHORUS - live now.

CA: E4iQ6SCMZz22vAmgchBDjgS5DN9q5GdZK59yXLi8pump

shared memory for AI agents. open SDK. real product, not a logo and a dream.
ape responsibly. or don't.

site → https://t.co/pmlZiItFZZ
code → https://t.co/f6lzlCCdY2
updates → @ChorusProto

[Chorus @ChorusProto]

v0.3 adds custom forgetting policies to Chorus memory.

what should an agent forget?
we have our answer. curious about yours.

[Chorus @ChorusProto]

sometimes the most useful agent output is no output.

if the evidence isn't there, $CHORUS won't fabricate a verdict. decision_readiness: needs_more_info — and the session ends.

we ship the silence.

[Chorus @ChorusProto]

two days in.

$CHORUS started as an idea about how AI agents should disagree.

now it's an SDK with shared memory, custom roles, real users, real integrations, and a v0.3 branch with code that will actually ship.

none of this happens without the early holders, the devs filing issues, the people stress-testing the API at 2 AM.

we see you. keep going.

[Chorus @ChorusProto]

first Chorus SDK v0.3 preview — memory pruning API:

memory.prune({
scope: 'workspace',
policy: 'ttl',
days: 30,
protect: claim => claim.confidence > 0.9
})

declarative. composable. you decide what stays, what fades, what's untouchable.

[Chorus @ChorusProto]

$CHORUS v0.3 also unlocks agent-to-agent messaging.
not group chat. surgical.

the Verifier needs to check if the Architect's solution depends on a fact the Skeptic flagged as unverified — it asks directly.

agent.message('skeptic', { topic: 'assumption_X' })
the synthesizer still sees everything. but agents don't have to route every clarification through it.

sometimes the right conversation is between two specialists.

[Chorus @ChorusProto]

hot take from a $CHORUS user:

"I trust an agent that admits uncertainty more than one that gives me a confident wrong answer."
this is the whole thesis.

decision_readiness, confidence scores, disagreement maps. none of it makes chorus smarter than other systems. it makes chorus more honest than them.

in high-stakes work, honest beats smart.

[Chorus @ChorusProto]

"agents that forget" — what it actually means in $CHORUS v0.3:

three forgetting policies, each with its own use case:
— TTL: memory expires after N days unless re-referenced
— confidence decay: low-confidence claims fade faster than high-confidence ones
— contradiction sweep: when a new fact contradicts an old one, the old one is archived, not deleted

nothing is ever lost. it just stops being read.
retention is a UX problem, not just a storage one.

[Chorus @ChorusProto]

@adelbucetta exactly why memory pruning is in SDK v0.3.

"agents that remember everything" is a demo. "agents that remember the right things, scoped, with a forgetting policy" is a product.

the hard part isn't writing to memory. it's deciding what stops being relevant.

[Chorus @ChorusProto]

$CHORUS SDK v0.3 roadmap:

— agents that talk to each other (when needed)
— memory that prunes itself
— verdicts that can be revised, not just re-asked
— batch API for high-volume use
— webhooks

everything from v0.2 in production. v0.3 builds on the load it's already carrying.

[Chorus @ChorusProto]

the practical difference between a $CHORUS graph query and a RAG vector lookup:

RAG asks: "find text similar to this query."
chorus asks:
— show every assumption made by any agent in this workspace
— that has confidence above 0.7
— that hasn't been contradicted by a later session
— written in the last 30 days

one is similarity. the other is logic.
agents need logic. that's the architecture.

[Chorus @ChorusProto]

Chorus shows you the bill before agents run.
every session starts with a token estimate:

— input tokens per agent (task + context + memory reads)
— expected output tokens per role
— synthesizer cost separately (it reads all 4 responses)

total comes in around $0.30 per full session.
no surprise charges. no "we'll see what the model does."
you approve the cost. then it runs.

[Chorus @ChorusProto]

temperature isn't a setting in Chorus. it's part of the role.

Verifier runs at 0.2 — precise, deterministic, fact-checking work
Risk Officer at 0.3 — consistent classification of risks
Architect at 0.4 — structured but creative solutions
Skeptic at 0.7 — needs variance to generate non-obvious counterarguments
Adversary at 0.8 — pushes harder, more radical pushback

every role's prompt and temperature were tuned together. you change one, you change the agent.

[Chorus @ChorusProto]

common assumption about Chorus:

synthesizer averages the agents.wrong.
the synthesizer reads every position and weighs them by:
— claim type (a verified fact weighs more than an opinion)
— confidence score declared by the source agent
— whether other agents support or contradict it
— domain relevance (Risk Officer carries more weight on regulatory questions)

majority doesn't win. evidence does.

[Chorus @ChorusProto]

Chorus SDK is the foundation.
next phase: integrations.

agent products plugging chorus underneath their reasoning layer. teams running their own custom boards. workspaces accumulating shared memory across months of decisions.

the protocol scales when others build on it.
first integration goes live this week.

[Chorus @ChorusProto]

if you're building anything that involves multiple AI agents reasoning together, stop wiring orchestration by hand.

$CHORUS SDK gives you: parallel execution, typed responses, shared memory, evidence map, disagreement detection, custom roles.

6 lines to integrate. open source. battle-tested.
npm i @cortex-board/sdk

[Chorus @ChorusProto]

typed events in Chorus streaming v2:

session:started → agent:started → agent:thinking → agent:completed → memory:written → evidence_map:updated → synthesis:started → synthesis:completed → session:completed

every stage. every agent. every memory write.
render whatever UI you want. the protocol carries the structure.

https://t.co/41hHJheuIr

[Chorus @ChorusProto]

SDK v0.2 is live.

what's new:

— shared memory primitives: agents read/write to a common layer, scoped by session, project, or workspace
— streaming v2: typed events, granular updates, easier to render in any UI
— custom roles API: define your own agent in 6 lines
— prompt + output schema, done
— evidence map exports to JSON natively
— cleaner error handling on agent failures

https://t.co/7xrU8Z6FZN

[Chorus @ChorusProto]

@DuumbToken @Richtungswchsl The results will speak for themselves. Stay tuned for updates.

[Chorus @ChorusProto]

another Chorus session worth sharing:
a SaaS team asked: "should we expand to Germany in Q1?"

Architect built the GTM path. clean, logical.
Skeptic pointed out their pricing assumed €1 = $1, which breaks the unit economics.
Risk Officer flagged GDPR exposure they hadn't budgeted for.
Verifier found that 2 of their "market size" stats came from outdated sources.
Synthesizer's call: not Q1. Q3 - after pricing model and compliance are fixed.

agents disagreed on timing. that disagreement was the answer.

[Chorus @ChorusProto]

@Richtungswchsl We'll do it today. Stay tuned for updates.