Studios Overview
A Studio turns governed collective intelligence into experiences your customers ship: a reusable unit of knowledge, AI, and humans that draws on the reasoning and memory graph.
The spine so far has been about making decisions trustworthy. Govern runs the Trust Loop on every agent decision, and Collective Intelligence compounds those decisions on a shared reasoning and memory graph. Studios are the payoff. They are where that governed intelligence stops being infrastructure and becomes something a customer opens, reads, and uses.
A Studio is the last step of the spine:
Govern your agents, run the Trust Loop on every decision, let Collective Intelligence compound on the graph, then ship it as a Studio.
What a Studio is
A Studio is a governed, reusable unit of knowledge, AI, and humans. Three things travel together inside it:
Knowledge
governed graph
The reasoning and memory the graph already holds: decisions, evidence, and the corrections your team made, not a fresh pile of documents.
AI
reasons over it
Models that answer, summarize, and explain by drawing on that governed knowledge, so every response can carry the decision behind it.
Humans
own and correct
Creators and co-creators who publish experiences and correct them in place, with each correction written back to the graph as durable context.
The combination is the point. A pile of documents is not a Studio, and neither
is a bare model endpoint. A Studio is the knowledge, the AI that reasons over
it, and the people who own and correct it, packaged as one thing you can publish
and others can use. In the API it is a publication, addressed by a unique url
such as ai-research-studio. See Core
Concepts for that entity model.
This is also where the platform's equation lands: AI + BI = CI. A Studio is the room where artificial intelligence and brain intelligence meet. Agents reason over governed knowledge, humans own and correct the result, and the collective intelligence that compounds between them is what your customers actually use.
How a Studio draws on the graph, and writes back to it
A Studio is not a fresh start. It is built on the reasoning and memory graph that Govern and Collective Intelligence have already filled. That is what separates a Studio from an ordinary content product: every experience it serves can draw on governed decisions rather than guesses. And the flow runs both ways: the questions people ask in a Studio, the preferences they set, and the corrections creators make write back to the same graph, so using a Studio compounds the layer it is built on.
- Reasoning is already structured. Each answer a Studio gives can carry the claims and evidence behind it, because the graph stored the reasoning, not just the output. See Understand.
- Memory is already governed. The corrections your team made on earlier runs ride along as durable context, so a Studio inherits judgment instead of relearning it. See Remember.
- Policy is already proven. The verdicts that fired during governance stay on the record, so an experience can show that what it served was checked, not asserted. See Prevent.
The experiences a Studio produces
A Studio expresses itself as experiences, and an experience holds resources: an AI Expert you can ask, a Note you can read, a Quest you work through, a Podcast you listen to. That content model is the subject of Experiences and resources, and you group experiences with Collections.
What makes those experiences worth shipping is the graph underneath. Two worked examples make the difference concrete.
Worked example: docs for your repos
Point a Studio at your repositories and it becomes living documentation that an engineer, or an agent, can question directly.
- A developer asks, "How does our billing service handle a failed webhook retry?" The Studio answers as an AI Expert resource.
- The answer is not a guess from stale Markdown. It draws on the reasoning the graph already captured: the decisions made when that retry path was built, the evidence behind them, and the policy checks that ran.
- When a reviewer corrected an earlier explanation, that correction is memory. The next person who asks gets the corrected answer, not the original mistake.
The result is documentation that explains why the code does what it does, with the decisions behind it attached, rather than prose that drifts out of date the moment it is written. To consume this same corpus in your own agent, see Use these docs in your agent.
Worked example: reports
A Studio turns a stream of governed decisions into a report a human can sign.
- A compliance lead needs a quarterly summary of every automated refund the support agents approved.
- The Studio generates it from the graph, so every figure traces back to the verdicts and corrections that produced it. A number in the report links to the decision that created it.
- Because the underlying decisions were governed, the report is defensible: each line carries its evidence and the rule that was checked, not an after-the-fact reconstruction.
A report built this way is auditable by construction. The work of proving it was done when the decisions were governed, not when the report was written.
Where to go next
Read the content model, then the way experiences are grouped.
Experiences and resources
The content model: experiences hold resources (AI Expert, Note, Quest, Podcast).
Collections
Group experiences into ordered, governed collections.
Collective Intelligence
The reasoning and memory graph a Studio is built on.
Use these docs in your agent
Query this whole corpus as context over MCP or as plain Markdown.
Collective Intelligence
The reasoning-aware, auditable, governable layer with the memory and context of your agents and your humans. Everything writes into it; everything is powered by it.
Experiences and resources
The content model inside a Studio. An experience is a container; a resource is the item inside it. Resources come in four types: AI Expert, Note, Quest, and Podcast.