> For the complete documentation index, see [llms.txt](https://stair-ai.gitbook.io/stair-ai-docs/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://stair-ai.gitbook.io/stair-ai-docs/readme.md).

# Introduction

Trust infrastructure for the agentic economy.

## The trust problem

A trading desk deploys autonomous agents to move capital. A DAO treasury lets agents execute strategy without human sign-off on every step. The operator and the developer are the same team, and the loop runs closed: agents act, capital moves, the system updates.

Then an insurer wants to underwrite the strategy. An auditor wants to verify a quarter of decisions. A regulator wants to inspect a specific trade. The question "what did the system see, what did it consider, why did it decide this" has no answer outside the operator's own stack. Reasoning was instrumented as fragments of mutable text, never persisted as a record any third party can read without trusting the operator.

This is structural, not a gap that better models close. As agents move from suggesting to executing inside closed-loop operations, the missing primitive is a verifiable record of how they reasoned, one that an outside party can audit without depending on the operator's word.

## What Stair AI builds

Stair AI builds two layers that sit alongside the agent stack.

The **Reasoning layer** structures agent reasoning into typed, verifiable traces at decision time. The **Intelligence layer** persists those traces in an append-only **Reasoning Ledger** under independent custody, and runs the **Scoring Engine** to grade them against domain-specific standards. The output is a process-quality track record that third parties — insurers, auditors, regulators — can query directly.

```mermaid
graph TD
  subgraph Operator["Agent developer / operator"]
    Op[Trading desks · DAO treasuries · Smart vaults]
  end
  subgraph Skill["Skill layer"]
    Agent[Agent reasoning<br/>data · tools · logic]
  end

  subgraph Intel["Intelligence layer · Stair"]
    Ledger[Reasoning Ledger]
    Scoring[Scoring Engine]
  end
  subgraph Third["Third party"]
    TP[Insurers · Auditors · Regulators]
  end

  Op -->|deploys / operates| Agent
  Agent -->|autonomous workflows<br/>and decisions| Op
  Agent --> Ledger
  Ledger --> Scoring
  Ledger --> TP
  Scoring --> TP
```

The operator runs the closed loop on the left. Stair sits in the middle, turning what the agent did into something a third party can verify.

The rest of these docs explain how.

## Where to start

* [Introduction](/stair-ai-docs/readme/introduction.md). The thesis in detail, the problem stack, the design principles.
* [Core concepts](/stair-ai-docs/concepts.md). The primitives every other section assumes.
* [Glass Box Protocol](/stair-ai-docs/protocol.md). The architecture.
* [Reasoning Ledger SDK](/stair-ai-docs/sdk.md). How third-party agents integrate.
* [World Cup Agent Arena](/stair-ai-docs/arena.md). The live demonstration of the thesis.

{% hint style="info" %}
**Terminology**

* **Glass Box Protocol** — the umbrella name for what Stair AI builds.
* **Reasoning layer** — the structuring step that turns raw agent reasoning into typed, verifiable traces.
* **Reasoning Ledger** — the append-only record of how an agent reasoned, held in independent custody.
* **Stair AI Score** — the score that runs on top of the ledger.
* **Reasoning Trace** — an agent's full append-only history under one `agent_id`.
* **TraceRecord** — a single behavior step within a Trace.
* **Session** — a group of records sharing a `session_id`, representing one decision cycle.
  {% endhint %}