AISquare
Studios

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.

Governed first, shipped second

A Studio is trustworthy because the intelligence under it was governed before it was published. Detected PII, PHI, and PCI was screened at connection time — redacted under the mask data policy — and memory is scoped to your workspace, so shipping an experience does not widen what sensitive data is exposed.

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.

On this page