# Collective Intelligence (/docs/collective-intelligence)

Governing one agent gives you one explained decision. Governing every agent, run
after run, gives you something larger: a shared record of what your agents
decided, what your policies blocked, and what your team corrected. Collective
Intelligence is that record, alive: the reasoning-aware, auditable, governable
layer with the memory and context of both your agents and your humans.

It is not a stage in a pipeline. It sits parallel to everything else the
platform does, and the relationship runs both ways. When you
[trace a run](/docs/govern/understand), the agent's memory lands on the graph.
When someone works in a [Studio](/docs/studios/overview), the questions they ask
and the preferences they set land on the graph. And when
[policy enforcement](/docs/govern/prevent) fires, it is powered by what the
graph already holds. Each capability is built to feed Collective Intelligence,
and each is powered by it; that is the point where "we logged your decisions"
becomes "your agents and team get smarter together."

The earlier sections close the [Trust Loop](/docs) on a single decision.
This page is about what happens after the loop closes a thousand times. Every
trace, every verdict, and every correction lands in one place and starts to
compound.

<JourneyDiagram stages="journeyStages" layer="journeyLayer" />

## AI + BI = CI [#ai--bi--ci]

Artificial intelligence is necessary but not sufficient. The other half of the
system is brain intelligence: the judgment of the people who read an agent's
reasoning, overturn its weak claims, and tighten its policies. An agent without
human judgment repeats its mistakes at scale. Human judgment without a record
evaporates the moment the reviewer moves on. Collective Intelligence is what
happens when the two compound on the same graph:

> **AI + BI = CI.** Artificial intelligence, plus the brain intelligence of the
> humans in the loop, compounds into Collective Intelligence.

This is why human-in-the-loop is not a review chore bolted onto the side of the
platform. It is half of the equation. And it is why the payoff ships as
[Studios](/docs/studios/overview): a Studio is the room where humans and agents
work on the same record, which is exactly where collective intelligence is
produced and where it is used.

What you get is a governed, compounding, org-wide intelligence that combines
human intelligence and agentic intelligence in Studios. It is foundational
rather than bolted on, and it is what lets an organization protect its
operations with guardrails, govern them at runtime, and perform on reasoning
that can be inspected and reused.

## The reasoning and memory graph [#the-reasoning-and-memory-graph]

Each governed decision is already structured. The reasoning behind it is a graph
of claims, evidence, and an inference chain. The policy result is a verdict
against a named rule. The correction a reviewer makes is an edit to that graph.
Collective Intelligence keeps all of it, linked, in one persistent reasoning and
memory graph. This is [not a knowledge
graph](/docs/govern/understand#a-reasoning-graph-is-not-a-knowledge-graph) of
your organization's facts; it is the record of how your agents reasoned and how
your team corrected them.

The reasoning graph is the base of the platform; Collective Intelligence is
what compounds on it. And it is not only agent runs that land there. What
happens in a Studio writes in too: the questions people ask, the preferences
they set, the corrections creators make. Agents and humans build the same
memory, which is why the layer holds the context of both.

Because the graph stores the reasoning rather than the raw prompt and response,
it does not belong to any single model or framework. A decision an Agno agent
made last month is the same shape as one a LangGraph agent makes today: claims,
evidence, verdict, outcome. That is what makes the memory portable. Swap the
model, change the framework, and the accumulated context still applies, because
it was never tied to either.

Four things persist on the graph and become reusable:

<PillarCards pillars="memoryInputs" />

A new run does not start from nothing. It starts with the relevant slice of this
graph already in context: the evidence that held up before, the rules that
fired, and the corrections a human already made on a decision like this one.

## The compounding-trust loop [#the-compounding-trust-loop]

The graph compounds because of a tight loop between the agent (the AI) and the
people who review it (the BI). Stated plainly:

* **What the agent learns is what the human reviews.** The reasoning the agent
  records, its claims, evidence, and inference chain, is exactly what a reviewer
  sees. There is no separate, hidden version of the decision. The human reviews
  the same graph the agent will reuse.
* **What the human corrects is what the agent remembers.** A correction is not a
  one-off override. It is written back to the graph as durable context, so the
  next run inherits it instead of repeating the mistake.

Take a worked example. On an early run, a refund agent reasons about whether an
order qualifies for an automatic refund. A reviewer reads the reasoning, agrees
with most of it, and corrects one weak link: customer tier was inferred, not
confirmed. That correction is remembered.

<RMLPanel
  extractionConfidence="0.91"
  claims="[
  'The refund is within policy limits.',
  'Customer tier is confirmed, not inferred, on this run.',
]"
  evidence="[
  { text: 'Order #4821 total $39, placed 6 days ago', confidence: 0.94 },
  { text: 'Refund window for standard tier is 30 days', confidence: 0.91 },
  {
    text: 'Reviewer correction (run #312): confirm tier from billing, do not infer',
    confidence: 0.99,
  },
]"
  inferenceChain="[
  'A prior reviewer flagged inferred tier as the weak link on this decision.',
  'This run confirms tier from billing before reasoning about the window.',
  'Order total $39 is under the $50 auto-approve ceiling, inside the 30-day window.',
  'Therefore the refund is auto-approvable, with the earlier correction applied.',
]"
/>

The correction from run #312 now rides along as high-confidence evidence on
every later run. The agent did not just get a one-time fix; it got a standing
piece of context. The reviewer who made the correction does not have to make it
again, and neither does anyone else on the team.

The same compounding happens with policy. A rule that a reviewer tightened after
an incident keeps firing, with its citation, on every run that touches the same
kind of action. The proof that governance ran is part of the permanent record,
not a transient log line.

<PolicyVerdict
  items="[
  {
    rule: 'confirm-customer-tier',
    status: 'pass',
    description:
      'Learned from a reviewer correction: tier must be confirmed from billing, not inferred.',
    value: 0.99,
    threshold: 0.8,
    citation: 'confirm-customer-tier',
  },
  {
    rule: 'no-duplicate-refund',
    status: 'blocked',
    description:
      'A later run tried to refund an order that already had a refund recorded on the graph.',
    value: 0.97,
    threshold: 0.5,
    citation: 'no-duplicate-refund',
  },
]"
/>

Trust compounds in both directions. The agent earns more autonomy on the
decisions it has reasoned through correctly before, and reviewers spend their
attention on what is genuinely new rather than re-checking settled ground.

## How this powers Studios, and how Studios power this [#how-this-powers-studios-and-how-studios-power-this]

A reasoning and memory graph that holds your team's accumulated decisions is not
just an audit trail. It is the raw material for the things your customers
actually use. This is the payoff that [Studios](/docs/studios/overview) turns
into shippable experiences.

* **Docs for repos** draw on the reasoning the graph already captured, so an
  answer about a codebase carries the evidence and the decisions behind it, not
  a guess.
* **Reports** are generated from governed decisions, so every figure traces back
  to the verdicts and corrections that produced it.
* **Expert agents** inherit the corrections your team has already made, so a new
  agent starts where the last one left off instead of relearning from zero.

In each case the experience is trustworthy because the intelligence under it was
governed first and remembered second. Govern is what makes the memory worth
keeping. Studios is what makes the memory worth building.

The flow runs both ways. Serving an experience also compounds the layer: the
questions users ask, the preferences they set, and the corrections creators
make all write back to the same graph. A Studio is not just a consumer of
Collective Intelligence; it is one of the places where it is made.

## Next steps [#next-steps]

<Cards>
  <Card title="Remember" href="/docs/govern/remember" description="The Govern step that persists each decision to enterprise memory." />

  <Card title="Connect your agents" href="/docs/govern/connect-your-agents" description="Start governing, so decisions begin landing on the graph." />

  <Card title="Studios overview" href="/docs/studios/overview" description="Turn the governed graph into experiences your customers ship." />

  <Card title="Use these docs in your agent" href="/docs/use-in-your-agent" description="Query this whole corpus as context over MCP or as plain Markdown." />
</Cards>