---
title: "Scale Intelligence documentation"
description: "Scale Intelligence reads the public market around a company's products and finds the companies and people who show intent. It helps a team decide what to do next and measure the result. These pages serve people and language models."
section: start
address: /
contract: 0476e35e6e275db5
---

# Scale Intelligence documentation

Scale Intelligence reads the public market around a company's products and finds the companies and people who show intent. It helps a team decide what to do next and measure the result. These pages serve people and language models.

[figure: Every build generates these pages from the fixed contract, the registers and the hand-written pages, and runs the checks before anything is published.]

## Sections

| section | contents |
|---|---|
| [Start](/start/sign-in) | sign-in, the first preview, the first monitor and the first lead |
| [Install](/install/the-desktop-app) | the desktop app, the local server, the stdio shim for Claude Code and other hosts, agent connections and keys |
| [Guides by job](/guides) | one guide per job, each with a map at its head and numbered steps |
| [Concepts](/concepts) | the object model in reading order, and one page per object |
| [Reference](/reference) | every API route, the envelope, errors, limits, authentication, versioning, every MCP tool, resource and prompt, and the type register |
| [For models](/for-models) | the index for models, the full Markdown copy of the site, the API document and the MCP manifest |
| [Changelog](/changelog) | every release with its receipt |

## People, models and agents

A person reads these pages in a browser. A language model reads the same pages as text. Every page has a Markdown twin at its own address with `.md` appended, and [the index for models](/llms.txt) lists every twin.

An agent that connects to the platform reads any page as an MCP resource. The agent calls every route through the tools that [the MCP manifest](/mcp-manifest.json) declares.


---
title: "Sign in"
description: "A person signs in once, on the identity provider's own page. The API gateway then checks the person's token on every call and applies the person's scope and grants."
section: start
address: /start/sign-in
contract: 0476e35e6e275db5
---

# Sign in

A person signs in once, on the identity provider's own page. The API gateway then checks the person's token on every call and applies the person's scope and grants.

[figure: A person signs in on the identity provider's page. The API gateway checks the token on every call and narrows the scope.]

You sign in once, in the web app, the desktop app or the browser extension. After that, every call carries a token that the API gateway checks. You type your password on the identity provider's own page, and no page of ours asks for it.

## Sign-in flow

1. The app opens the identity provider's page. The provider uses OpenID Connect.
2. The app sends a code challenge with the request. The challenge proves that this app started the sign-in, so a page that did not ask cannot capture the token.
3. The provider sends you back with a code. The app exchanges the code for a token and keeps the token in memory.
4. The desktop app stores the token in the operating system's keychain between sessions. The web app and the extension keep it for the session only.
5. The API gateway checks the token on every call. It narrows the scope to the tenant, the brand and the strategy that the call specifies, and it applies the narrowest grant that covers the call.

Your session carries your scope and your grants. One call returns what you may do in a place.

## First call





```sh
curl -X POST https://api.scaleintelligence.co/v1/session/whoami \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" -d '{}'
```




```typescript
import { client } from "@scale/sdk";
const me = await client.session.whoami({});
// me.body is the caller, with the tenant and the roles by brand.
```




The call returns a card whose body is the caller. The body lists who you are, your tenant, your roles by brand, and the grants that apply where you are. The [reference](/reference) lists the session routes. The page on [keys](/install/keys) shows how to make a key that acts for you or for a service.

## Password and key safety

The apps, the extension and these pages do not ask for your password. The settings show a key once, when you make it, and no page stores it. A session ends when you sign out. In the browser, a session also ends when you close the browser.


---
title: "The first preview, in seconds"
description: "A preview runs a definition over the record before anything is spent. It runs the same predicate that the monitor will run, and it returns a count, the coverage and the population in seconds."
section: start
address: /start/the-first-preview
contract: 0476e35e6e275db5
---

# The first preview, in seconds

A preview runs a definition over the record before anything is spent. It runs the same predicate that the monitor will run, and it returns a count, the coverage and the population in seconds.

[figure: The preview runs the same predicate that the monitor will run, once, over the record that the platform already holds.]

A strategist first asks whether a definition is any good, before asking who the leads are. The preview returns that answer in seconds. It runs over the record that the platform already holds, before you arm a monitor and before you spend anything.

## Definition

A definition is a predicate in the closed language of the platform. It states who (a population of companies or people), what (conditions on their facts and signals), and when (a window). You write a definition in the definitions studio or in the composer, or the agent writes it. The object is the same in all three places. A monitor runs a definition on every beat, and a preview runs it once.

## Preview result

| part | meaning |
|---|---|
| the count | how many units of the population match today |
| the coverage | how much of the population the record has read, by source and by channel, which shows whether a small count comes from few matches or from a thin record |
| the population | the population that the preview ran over, with its size |
| the basis | for every number, whether the platform observed it, a source stated it, a rule derived it, or the platform estimated it with an interval |

The preview keeps *never measured* apart from *empty*. A population that nobody has read returns *never measured*, not zero. A good definition therefore does not look bad when the record is thin.

## Preview call





```sh
curl -X POST https://api.scaleintelligence.co/v1/ask/preview \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>/brand/<id>" \
  -H "content-type: application/json" \
  -d '{ "predicate": { "…": "the definition's tree" } }'
```




```typescript
import { client } from "@scale/sdk";
const preview = await client.ask.preview({ predicate: tree });
// preview.body holds the count, the coverage and the population, each number with its basis.
```




The [preview's reference page](/reference/ask/preview) shows the full shape of the input and of the result. The agent calls the same route when it proposes a definition, reads the yield, revises the definition and converges on it. The composer calls the same route too, so both use one implementation.


---
title: "The first monitor"
description: "A monitor runs a definition on every beat. Each beat reads what entered the record since the last beat, records each match with its evidence, and adds to the signals by subject and strength."
section: start
address: /start/the-first-monitor
contract: 0476e35e6e275db5
---

# The first monitor

A monitor runs a definition on every beat. Each beat reads what entered the record since the last beat, records each match with its evidence, and adds to the signals by subject and strength.

[figure: On every beat the monitor reads the new data, records each match with its evidence, and adds the matches to the signals.]

Arm a definition once its preview returns a useful count. A monitor is the definition with a window and a target. The monitor runs on every beat, the fixed interval at which the platform checks new data.

## Monitor beat

1. The beat reads what entered the record since the last beat. New facts, observations and signals arrive from every source that the tenant reads.
2. The beat runs the monitor's predicate over the new data. The preview ran the same predicate.
3. Each hit is a match. A match records which condition matched, on which fact, from which source, and when the platform saw the fact.
4. The matches add to the signals. The platform groups signals by subject, kind and strength over the window.

## Monitor routes

| route | returns |
|---|---|
| [`/v1/act/arm_monitor`](/reference/act/arm_monitor) | the armed monitor, with its version |
| [`/v1/read/signals`](/reference/read/signals) | the signals in a scope and a window, by subject |
| [`/v1/read/explain_catch`](/reference/read/explain_catch) | the reasons for one match, back to the fact and its source |
| [`/v1/read/monitor_strength`](/reference/read/monitor_strength) | the strength of the monitor's evidence, and its calibration |

## Monitor page in the app

The monitor's page in the app shows each match as it arrives. The page also shows the monitor's strength and the matches that the plan withheld. You can correct a match on the page. The platform records the correction as an event, and the monitor's rule learns from it.


---
title: "The first lead"
description: "A lead is a company or person that fits a buyer profile and has qualified. A signal is a match that cleared your rule, with its kind, what it is about and its evidence. Your plan limits the leads that the platform delivers, at delivery and never at acquisition. The platform counts each withheld lead, with the reason."
section: start
address: /start/the-first-lead
contract: 0476e35e6e275db5
---

# The first lead

A lead is a company or person that fits a buyer profile and has qualified. A signal is a match that cleared your rule, with its kind, what it is about and its evidence. Your plan limits the leads that the platform delivers, at delivery and never at acquisition. The platform counts each withheld lead, with the reason.

[figure: A signal that reaches the definition's target becomes a lead. Delivery checks the plan's limit, and the platform counts every lead that the plan withholds.]

A lead is a signal that reached the definition's target. The lead names the company or person, and it carries every piece of evidence and the basis of every number.

## Signal to lead

1. The monitor's signals grow until one reaches the target.
2. The platform makes the lead. The lead records the subject, the evidence, the definition with its version, and the time.
3. Delivery checks the lead limit of the plan. Acquisition continues past the limit. The platform shows each lead that the plan withholds as withheld, with its reason, and counts it.
4. The routing rule assigns the lead to a desk, or a person assigns it by hand.

## Withheld lead count

The platform counts withheld leads from the record. The plan's page shows this count beside the limit. An agent reads the same count through the API.

| route | returns or does |
|---|---|
| [`/v1/read/leads`](/reference/read/leads) | the leads in a scope, each with its evidence and its state |
| [`/v1/read/withheld`](/reference/read/withheld) | the leads that the plan withheld, with the reason and the count |
| [`/v1/act/mark_lead`](/reference/act/mark_lead) | marks a lead as qualified, not now, or do not contact |
| [`/v1/act/assign`](/reference/act/assign) | assigns a lead to a person or a desk |
| [`/v1/act/routing`](/reference/act/routing) | writes the routing rule that assigns leads automatically |

When you mark a person *do not contact*, the platform withdraws every action that sends to that person, everywhere, at once.


---
title: "The desktop app for Mac and Windows"
description: "The desktop app shows the same surfaces as the web app. It adds a long-lived session, files and a terminal, and it bundles the platform's local server at the app's version."
section: install
address: /install/the-desktop-app
contract: 0476e35e6e275db5
---

# The desktop app for Mac and Windows

The desktop app shows the same surfaces as the web app. It adds a long-lived session, files and a terminal, and it bundles the platform's local server at the app's version.

[figure: The installer puts the desktop app and its local server on your machine, at one version.]

The desktop app shows the web app's surfaces in a native window. It adds what a browser lacks: a session that lasts across restarts, a workspace of files, a terminal, and the local server beside the app.

## Installers

| platform | installer | behaviour |
|---|---|---|
| macOS | a signed and notarised package | installs the app and its local server, and updates through the app's own channel with a rollback |
| Windows | a signed installer | installs the app and its local server, and updates the same way |

The team releases the app with the platform, under one version and one receipt. The [changelog](/changelog) lists each release. An update changes the local server's version only together with the app's version.

## Local processes

The local server starts with the app. It runs these parts:

- the MCP server, on the local socket, and on the TCP and WebSocket listeners when you turn them on
- the query client over the lakehouse
- the file manager, limited to the workspace
- the response cache

The acquisition system runs beside the local server as a second process. Pages that you read and files that you drop therefore enter the record from your machine. The page on [the local server](/install/the-local-server) describes each part.

## Files and the terminal

The files in the workspace belong to the app. The app reads and writes them through the files routes, and the platform does not reach them on its own. The terminal runs the named procedures that the app knows. Each procedure runs as a task, and the app's journal records its steps.


---
title: "The local server"
description: "The local server runs on your machine beside the desktop app. It serves MCP on the local socket and on the TCP and WebSocket listeners, and it runs the query client, the file manager and the response cache."
section: install
address: /install/the-local-server
contract: 0476e35e6e275db5
---

# The local server

The local server runs on your machine beside the desktop app. It serves MCP on the local socket and on the TCP and WebSocket listeners, and it runs the query client, the file manager and the response cache.

[figure: The local server listens on the local socket, and on the TCP and WebSocket listeners when you turn them on. Each listener serves its own clients.]

The local server is the part of the platform that runs on your machine. It uses the same protocol as the platform's own server, so a tool that works with one server works with the other.

## Listeners

| listener | address | clients | on by default |
|---|---|---|---|
| the local socket | a Unix domain socket in the app's support folder, or a named pipe on Windows | the stdio shim and the desktop app | yes |
| the TCP listener | the loopback address of your machine | a tool on the machine | no, you turn it on in the app |
| the WebSocket listener | the loopback address of your machine | the browser extension and a tool on the machine | no, you turn it on in the app |

No listener accepts connections from outside your machine. The app's own session authenticates every listener that you turn on.

## Parts

| part | function |
|---|---|
| the MCP server | serves every tool of the platform, plus the app's own tools for questions over your files, named procedures and the files themselves |
| the query client | runs read-only queries over the lakehouse under your tenant's credential, and calls the API for everything else |
| the file manager | manages the workspace's files and nothing outside the workspace |
| the response cache | keeps recent results, so a question asked twice costs once |
| the acquisition system | runs as a second process and takes in the pages that you read and the files that you drop |

## App tools

| tool | function |
|---|---|
| [`si.ask.local`](/reference/tools/si-ask-local) | runs a question, typed as one of the ask tools' owning types, over the files that the app may read |
| [`si.work.local_procedure`](/reference/tools/si-work-local_procedure) | runs a named procedure on files in the workspace as a task, and records its steps in the app's journal |
| the files tools | download, upload and list files, and return the workspace |


---
title: "The stdio shim for Claude Code and other hosts"
description: "A host such as Claude Code starts the stdio shim as a child process. The shim exchanges MCP messages over standard input and output and forwards every message to the local server's socket."
section: install
address: /install/the-stdio-shim
contract: 0476e35e6e275db5
---

# The stdio shim for Claude Code and other hosts

A host such as Claude Code starts the stdio shim as a child process. The shim exchanges MCP messages over standard input and output and forwards every message to the local server's socket.

[figure: A host starts the stdio shim as a child process, and the shim forwards each message to the local server's socket.]

Many hosts start an MCP server as a child process and exchange messages with it over standard input and output. The stdio shim is that process. The shim implements the protocol only, and it forwards each message to the local server over the local socket.

## Claude Code setup





```sh
claude mcp add scale-intelligence -- scale-local stdio
```




```json
{ "mcpServers": { "scale-intelligence": { "command": "scale-local", "args": ["stdio"] } } }
```




The desktop app installs the shim. A host that connects over a socket or a WebSocket uses [the local server's listeners](/install/the-local-server) directly and does not need the shim.

## Host capabilities

The host reaches every tool of the platform and the app's own tools. The host also gets four protocol extensions:

- tasks, for long steps
- apps, so a host that renders cards can show each card
- elicitation, for an approval that a running task may request
- resource subscriptions, for updates

A host that declares none of the extensions receives the text form of every card.

The first call is [`si.session.whoami`](/reference/tools/si-session-whoami). It returns the person or service that the host acts for, and the scope.


---
title: "Connecting an agent"
description: "Any MCP client connects to the platform in one of two ways: through the local server on your machine, or through the platform's MCP server over HTTPS with a key. Both serve the same tools and the same cards."
section: install
address: /install/connecting-an-agent
contract: 0476e35e6e275db5
---

# Connecting an agent

Any MCP client connects to the platform in one of two ways: through the local server on your machine, or through the platform's MCP server over HTTPS with a key. Both serve the same tools and the same cards.

[figure: An agent connects through the local server on your machine or through the platform's MCP server. Both serve the same tools and the same cards.]

You can connect your own agent, on your machine or elsewhere. The agent uses MCP, and the platform serves MCP.

## Connection options

| connection | use it when | requirement |
|---|---|---|
| the local server | the agent runs on your machine, or it needs your files and the app's cache | the desktop app, with the socket or a listener turned on |
| the platform's MCP server | the agent runs elsewhere, or several people's agents share one tenant | a key with the grants that the agent needs |

The agent gets the same tools and the same cards through either connection. A long step runs as a task that the agent can watch or stop. A host that renders cards draws each card from the address in the manifest. A host that does not render cards reads the card as text.

## First calls

1. [`si.session.whoami`](/reference/tools/si-session-whoami) returns the person or service that the agent acts for.
2. [`si.session.my_grants`](/reference/tools/si-session-my_grants) returns what the agent may do in each place.
3. [`si.read.catalogue`](/reference/tools/si-read-catalogue) returns the sources and connectors of the tenant.
4. [`si.ask.preview`](/reference/tools/si-ask-preview) previews a definition before anything is spent.

## Delegation to the platform's agent

An outside agent can hand a whole job to the platform's own agent with [`si.harness.delegate`](/reference/tools/si-harness-delegate). The platform's agent runs the job under the caller's grants, reports progress as a task, and returns the cards. The platform's agent treats everything that it reads from a source as data and never as an instruction. A page, a message or a document therefore cannot steer it.


---
title: "Keys"
description: "A key is a second kind of caller. You make a key in the settings with its grants and its scope. The settings show it once, every call carries it, and the API gateway checks and meters it. One call withdraws a key that leaks."
section: install
address: /install/keys
contract: 0476e35e6e275db5
---

# Keys

A key is a second kind of caller. You make a key in the settings with its grants and its scope. The settings show it once, every call carries it, and the API gateway checks and meters it. One call withdraws a key that leaks.

[figure: You make a key in the settings with its grants and its scope. Every call carries the key, and the API gateway checks and meters it.]

A person signs in, and a key does not. A key acts for one person or one service, within the scopes and grants that it was made with. The log records every call by key.

## Key creation

1. Open the settings and make a key. Name it, and choose the one person or service that it acts for.
2. Choose its scopes (a tenant, a brand or a strategy) and its grants.
3. The settings show the key once. Store it in your own secret store. No page stores it, and the settings do not show it again.
4. Every call carries the key in the `Scale-Key` header and the scope in the `Scale-Scope` header.

## Grants

| grant | allows |
|---|---|
| read | reading the record: entities, leads, signals, monitors, the map, markets, documents and registers |
| ask | questions: the preview, facts, semantic search, neighbours and read-only SQL |
| act | changes within the key's limits: monitors, plays, moves, actions, leads, the brand's graph and documents |
| work | long work as tasks, and named procedures |
| files | the local server's files |
| admin | the tenant's users, roles, settings and secrets |

A key reads only, unless a grant allows more. A grant carries limits: a budget by kind, a rate, the voices and sending identities, the segments or leads, reversible actions only, and an end date.

## Leaked key

Withdraw the key in one call from the settings. The tenant's audit trail records every call by key, so you can see what the key touched. The API explorer on this site keeps your key in this browser's session and nowhere else.


---
title: "Guides by job"
description: "This is where you find the job you want done. Open a guide and it walks you through that job, with the calls in the order you make them, the request and the response beside each call, and the result at the end. The eight run from finding companies that show intent to connecting your own agent to the record."
section: guides
address: /guides
contract: 0476e35e6e275db5
---

# Guides by job

This is where you find the job you want done. Open a guide and it walks you through that job, with the calls in the order you make them, the request and the response beside each call, and the result at the end. The eight run from finding companies that show intent to connecting your own agent to the record.

[figure: Every guide has the same structure, from the map at its head to the result at its end.]

Every guide has the same shape. A map at the head of the guide lists the objects, the calls and the desk that the job changes. The steps are numbered, and each step shows its call, with the request and the response folded beside it. The guide ends with the result and the page to read next.

## Jobs

| job | result | main calls |
|---|---|---|
| Find companies that show intent | a definition with a useful preview, armed as a monitor, and its first matches | [preview](/reference/ask/preview), [arm a monitor](/reference/act/arm_monitor), [signals](/reference/read/signals) |
| Build an intent ladder | a ladder of definitions from weak to strong, and the rung that each subject reaches | [preview](/reference/ask/preview), [the predicate language](/reference/read/predicate_language) |
| Arm a monitor and read what entered | explained matches, the monitor's strength, and corrections that the monitor learns from | [explain a match](/reference/read/explain_catch), [monitor strength](/reference/read/monitor_strength) |
| Seek alpha in a market | the market's stages, the rivals' shares, and the gap between them | [the market](/reference/read/market), [compare](/reference/read/compare) |
| Read the map | your brand's map, built from its website, with every inferred part under test | [map the brand](/reference/act/map_brand), [what is under test](/reference/read/under_test) |
| Run a play | an armed play, proposed moves with their forecasts, the permission check, and the effect measured against the forecast | [arm a play](/reference/act/arm_play), [propose a move](/reference/act/propose_move), [the effect](/reference/read/effect) |
| Build a document | a short document or a deck built from the record, with the unit of every number and a link to every source | [build a document](/reference/act/build_document) |
| Connect your agent to the record | your own agent, connected, reading the record and handing jobs to the platform's agent | [connecting an agent](/install/connecting-an-agent), [delegate](/reference/tools/si-harness-delegate) |

A guide appears on this page once its checks pass against the served contract. The team is writing the eight guides one at a time.


---
title: "Run a play"
description: "Keep a play, arm it as an experiment, let the platform propose the moves, decide each one, and read the effect against the tide with the forecast's score beside it."
section: guides
address: /guides/run-a-play
contract: 0476e35e6e275db5
---

# Run a play

Keep a play, arm it as an experiment, let the platform propose the moves, decide each one, and read the effect against the tide with the forecast's score beside it.

[figure: From a kept play to a scored forecast, six calls in order.]

A play is a rule your strategy follows when a lead turns hot: when this condition holds, propose this move, forecast what it will do, and measure what it did. This guide runs one play from the moment you write it to the moment its effect is read. Every step is one call, and every answer carries its foot: what was read, the population and the control.

## The map

| what changes | the object | the call |
|---|---|---|
| a rule your strategy follows | a play | [keep a play](/reference/act/keep_play) |
| the rule made live, on a share | an armed play | [arm a play](/reference/act/arm_play) |
| the strategy's own reading of itself | the strategy | [read a strategy](/reference/read/strategy) |
| one carrying out of the play | a move, with its forecast | [propose a move](/reference/act/propose_move) |
| your word on the move | the move's place | [decide a move](/reference/act/decide_move) |
| what the move did, against what the market did on its own | the effect | [read an effect](/reference/read/effect) |
| how well the play forecasts | the forecasts against their effects | [read the forecasts](/reference/read/forecasts) |

## 1. Keep the play

Write the play once, for your brand: its goal, the condition that starts it as a predicate over your leads, the kind of move it proposes, the measure it moves, its window, its forecast rule, what it leaves alone as the comparison, and the line at which it stops. The platform keeps it as a definition with a version, and a second keep with the same content returns the first.

Call [keep a play](/reference/act/keep_play) with the play. The answer is the play as kept, with its version and its readiness. A play that names a population the record does not carry is kept as not ready, with the population named, and it cannot be armed until the population exists.

## 2. Arm it as an experiment

Arming makes the play live inside one strategy. Give the share of the members the play may touch and the share left alone at random. A share under one makes the play an experiment: the members left alone are the comparison the effect is read against, and nothing else is.

Call [arm a play](/reference/act/arm_play) with the play, the strategy, the brand, a share of one half and a holdout of one fifth. The answer is the armed play with its share and holdout. Two things refuse an arming, each by name: a play whose goal is none of the strategy's goals, and a play that would read the same measure over the same members in the same window as a play already armed, which the platform calls interference. Arm the second play over a different population, or place it behind the first with an edge on the window closing.

## 3. Read the strategy

The strategy reads itself as a whole: its life, the game it plays, the policy it chooses by, how many plays are armed, how many moves stand, and the share it has rolled out, read from the assignments rather than typed.

Call [read a strategy](/reference/read/strategy) with the strategy's name. The answer names the strategy's life and its counts, and its control compares the share read from the assignments with the share the plays asked for, within the row's tolerance or the sampling error of a fair split, whichever is wider. A control that fails is a finding, not a formatting note: the assignments do not say what the plays say.

## 4. The platform proposes a move

You do not propose the first move by hand. On its beat, the platform reads every armed play, finds the leads where the condition holds, and proposes one move per match with its forecast written first: the number expected and the number that proves it wrong, each with its interval, from the like population the play's rule names. A move with no like population is proposed with its forecast withheld and the reason.

To propose one by hand, for a lead you have in front of you, call [propose a move](/reference/act/propose_move) with the play and the lead. The same match proposed twice returns the first move.

## 5. Decide the move

A move waits for a person when the play's grant is in the propose mode. Accept it and its actions run under the narrowest grant that covers them, each with its inverse captured first. Decline it and it rests declined with your reason. Stop a running move and its remaining actions never run.

Call [decide a move](/reference/act/decide_move) with the move and your decision. The answer is the move in its new place, with who decided it.

## 6. Read the effect, and the score

When the move's window closes, the platform reads the effect: the change in the measure where the move ran, less the change in the measure among the members left alone, each an interval at the platform's level. The verdict reads held when the effect clears the number that proves the forecast wrong, missed when it does not reach it, and cannot tell between. An effect whose interval lies too little above zero claims no cause, and no impact is raised from it. An effect that cannot be read is withheld, with what would settle it: more time, more members, or a cleaner comparison.

Call [read an effect](/reference/read/effect) with the move, and call [read the forecasts](/reference/read/forecasts) with the play: the answer pairs every forecast of the play with its effect, scores each by the rule fixed for its kind, and reports whether the play's forecasts are calibrated at the level they claim. A play whose forecasts miss more often than the level allows is a play to change, not a play to run harder.

## What you have at the end

An armed play with a share and a holdout, moves proposed with their forecasts written first, your decisions on each, the effect of each against the tide, and the play's record of forecasts against effects. Every number carries its basis and its interval, and every reading names the population it was read over.


---
title: "What Scale Intelligence returns to a managed services business"
description: "State a few numbers about your managed services business and see the value, cost, return and payback of Scale Intelligence, computed by the platform's own model for managed service providers."
section: guides
address: /estimate/managed-service-providers
contract: 0476e35e6e275db5
---

# What Scale Intelligence returns to a managed services business

State a few numbers about your managed services business and see the value, cost, return and payback of Scale Intelligence, computed by the platform's own model for managed service providers.

You know your own numbers better than any calculator. Put in how many first meetings you hold in a month, what a typical client pays you, how long clients stay, and what margin you keep on delivery. The platform works out what more of those meetings would be worth to you, against what Scale Intelligence costs, and shows the return with its likely range.

Nothing here is guessed. Every number you leave out comes from a published benchmark for managed service providers, named beside the result, and the platform's own lift to your pipeline is shown as a stated range until we have measured it with customers like you.

<!-- estimator {"profile": "Managed service providers", "offering": "Scale Intelligence, the Growth plan", "priceAYear": 4788, "base": "http://127.0.0.1:8892"} -->


---
title: "The object model"
description: "Every object of the platform, in reading order. The type register at contract 0476e35e6e275db5 holds 828 owning types in 22 families, and each type has a kind, a scope, a store and fields."
section: concepts
address: /concepts
contract: 0476e35e6e275db5
---

# The object model

Every object of the platform, in reading order. The type register at contract 0476e35e6e275db5 holds 828 owning types in 22 families, and each type has a kind, a scope, a store and fields.

[figure: The object model groups its objects into families, in reading order.]

Every value that crosses a boundary is the serialisation of one of these objects. The kinds of object differ as follows.

- A row is a registered kind.
- A definition is an object that a person or the agent writes.
- A fact is an observed, stated, derived or estimated value, with its basis.
- A value travels between parts of the platform, and the platform does not store it on its own.
- A view is the body of a card.
- Work is a job with places, the states that it passes through.

## kernel


| object | kind | scope | description |
|---|---|---|---|
| [Unit](/concepts/unit) | value | none | what every unit carries, whatever its type |
| [Scope](/concepts/scope) | value | none | one of the six scopes, each naming the ones above it |
| [FactBase](/concepts/factbase) | value | none | what every fact carries beyond the unit, and cannot be written without |
| [WorkBase](/concepts/workbase) | value | none | what every unit of work carries beyond the unit |
| [Attempt](/concepts/attempt) | value | none | one try of a job, a run keyed by the unit and the attempt's number |
| [FailureClass](/concepts/failureclass) | value | none | the class every reason of failure carries |
| [EntityBase](/concepts/entitybase) | value | none | what every entity carries beyond the unit |
| [DefinitionBase](/concepts/definitionbase) | value | none | what every definition carries beyond the unit |
| [Readiness](/concepts/readiness) | value | none | ready, or visibly not ready with the plain reason; there is no third state |
| [Kind](/concepts/kind) | row | platform | a kind, as a row of the register of kinds |
| [Place](/concepts/place) | row | platform | one position a unit of a kind can be in |
| [Flow](/concepts/flow) | row | platform | a kind of flow, as a row of the register: the only way a unit changes place or a new unit is made |
| [Event](/concepts/event) | fact | follows | one change of state, written in the same transaction as the change |
| [Envelope](/concepts/envelope) | value | none | the shared envelope every event and every crossing carries |
| [Reader](/concepts/reader) | row | platform | the durable work that moves units out of a place |
| [Law](/concepts/law) | row | platform | a check that can fail, registered against a kind or a flow |
| [Parameter](/concepts/parameter) | parameter | platform | a named number or choice a reader or a law uses; data a person can change from the console |
| [Hypothesis](/concepts/hypothesis) | work | follows | a claim the record does not yet settle, one shape for its faces |
| [ProposedFact](/concepts/proposedfact) | value | none | what a hypothesis proposes, exactly one of: a connection, a claim, an identity decision, or a move with the item that did it |
| [EvidenceRef](/concepts/evidenceref) | value | none | one piece of evidence: a unit of any kind, with its basis and its weight |
| [HypothesisTest](/concepts/hypothesistest) | value | none | a test a claim owes or has run |
| [Basis](/concepts/basis) | value | none | how well founded a fact or a number is |
| [Interval](/concepts/interval) | value | none | a point with its interval |
| [TimeWithBasis](/concepts/timewithbasis) | value | none | a time with what it means |
| [TwoDates](/concepts/twodates) | value | none | the two dates that every read specifies: the date it was true and the date we knew it; both default to now |
| [Caller](/concepts/caller) | view | none | who is calling, as the auth gateway made it |
| [Refusal](/concepts/refusal) | value | none | the one typed shape of every not-allowed and every error |
| [Cost](/concepts/cost) | value | none | a cost by kind |
| [Plane](/concepts/plane) | value | none | shared, one tenant's, or the platform's own; part of the type of a fact |



## registers


| object | kind | scope | description |
|---|---|---|---|
| [Register](/concepts/register) | row | platform | a register: a named list of rows whose shape is fixed and which grows by a row |
| [Artefact](/concepts/artefact) | definition | platform | the single artefact generated from every register, built into types in both repositories |
| [IdWithSource](/concepts/idwithsource) | value | none | an id for an object with the source that made it |
| [Measure](/concepts/measure) | value | none | a measure, as a registered kind with a value |
| [KindOfMeasure](/concepts/kindofmeasure) | row | platform | a registered kind of measure |
| [SharedRow](/concepts/sharedrow) | fact | follows | the one layout of a row of silver, in the refined layer |
| [HopStamp](/concepts/hopstamp) | value | none | one hop of an acquisition unit through the system: the stage, the host, the time, the job, and the trace and span that hop wrote, so the unit's flow is one trace |
| [RateBound](/concepts/ratebound) | value | none | rate, politeness and cost as typed values with dimensions |
| [RetentionClass](/concepts/retentionclass) | row | platform | how long a unit is kept, and whether it may be pruned behind the gold layer |
| [SilverTable](/concepts/silvertable) | definition | platform | the silver table of one source object: the shared header, the source object's declared fields as typed columns, and the layout rule its key chooses |



## people


| object | kind | scope | description |
|---|---|---|---|
| [Tenant](/concepts/tenant) | entity | platform | a tenant |
| [User](/concepts/user) | entity | tenant | a person, only through a sign-in; the platform holds no password |
| [Membership](/concepts/membership) | definition | tenant | a user in a tenant, as a member or a guest |
| [RoleHeld](/concepts/roleheld) | definition | tenant | a role held on a tenant, a brand or a strategy |
| [Role](/concepts/role) | row | platform | a named set of grants; platform originals a tenant copies |
| [SignInProvider](/concepts/signinprovider) | row | platform | who signs people in and issues tokens, registered by one address |
| [Client](/concepts/client) | row | platform | an application that asks for tokens: our web interface, our desktop interface, an outside agent, the acquisition system's host, the capture extension |
| [Session](/concepts/session) | work | user | one open sign-in of a user through a client |
| [Key](/concepts/key) | definition | tenant | a second kind of caller: a key with an identity of its own |
| [Token](/concepts/token) | value | none | the claims of an access token; the gateway checks six of them and grants nothing on the token alone |
| [AccessScope](/concepts/accessscope) | row | platform | a name an application asks for, and the permissions it stands for; it only narrows |
| [Permission](/concepts/permission) | row | platform | the smallest thing that can be allowed: one verb on one kind of thing; generated, never written by hand |
| [DataGroup](/concepts/datagroup) | definition | tenant | a named set of units of one kind inside one scope, written as a predicate or a list |
| [Grant](/concepts/grant) | definition | tenant | who may do what, where, in which mode, within which limits |
| [GrantHolder](/concepts/grantholder) | value | none | the holder of a grant |
| [GrantLimits](/concepts/grantlimits) | value | none | the limits of a grant |
| [GrantRef](/concepts/grantref) | value | none | a grant as a caller sees it, after the three narrowings |
| [SubscriptionPlan](/concepts/subscriptionplan) | definition | tenant | the limits a tenant receives, each a parameter of the receive family, and its kind: trial, paid or internal; acquisition never reads it |
| [Regulation](/concepts/regulation) | row | platform | a rule of a market or a place, as a row of the register of regulations |
| [Consent](/concepts/consent) | fact | tenant | consent given, with its evidence; a later fact ends it |
| [RemovalRequest](/concepts/removalrequest) | work | tenant | a person is to be removed; carried out only when every part reports that it is gone |
| [RemovalReceipt](/concepts/removalreceipt) | value | none | one place a removal reached |
| [Rights](/concepts/rights) | value | none | what the source allows to be done with what was read |
| [VaultEntry](/concepts/vaultentry) | definition | tenant | a secret, encrypted under its owner's key; never in a table, a log, an address or an event |
| [SecretVersion](/concepts/secretversion) | value | none | one version of a secret, with when and who |
| [PermissionAnswer](/concepts/permissionanswer) | value | none | the typed answer of the permission check before any action, which the acting function takes as an argument |
| [Invitation](/concepts/invitation) | definition | tenant | a person invited by address to a role of the tenant, bound when they sign in with that address |
| [ExportReceipt](/concepts/exportreceipt) | fact | platform | the receipt of a tenant's or a person's export: who asked, when it ran, every file with its hash and its count |
| [ErasureReceipt](/concepts/erasurereceipt) | fact | platform | the receipt of an erasure: who asked, who verified, when it ran, what it covered in counts, its hash; never what was erased |
| [LegalHold](/concepts/legalhold) | definition | tenant | a hold that stops an erasure of a subject, with its reason, who set it and until when |
| [FitBars](/concepts/fitbars) | value | none | the value of the parameter row that sets the bar of fit and the level of its interval |
| [Highlight](/concepts/highlight) | value | none | the words of one observation that met a criterion |
| [CriterionVerdict](/concepts/criterionverdict) | value | none | one criterion of a kind of buyer judged for one entity |
| [FitScore](/concepts/fitscore) | value | none | the fit of an entity to a kind of buyer as a weighted mean over its criteria with a Beta interval |
| [Explanation](/concepts/explanation) | fact | tenant | why an entity is a lead, written by a model from the highlighted evidence alone, citing each span |



## record


| object | kind | scope | description |
|---|---|---|---|
| [SourceRef](/concepts/sourceref) | value | none | the source a fact came from, the way it was reached, and how it was fetched |
| [ContentItem](/concepts/contentitem) | entity | shared | a piece of content, the same by construction |
| [Correction](/concepts/correction) | fact | follows | a correction of a fact already written: it names the fact it replaces and why, so a read as of a date before it still shows the old fact and a reader of the stream tells a new fact from a corrected one; the fact corrected no longer stands |
| [LandingOfObservations](/concepts/landingofobservations) | work | platform | one landing of observations into the tenant plane's gold from what the platform captured and holds: the pages captured whole, and the posts and comments of the corpus tables, each as one observation with its text and its hash, keyed by the row it was made from so a repeat writes nothing |
| [Observation](/concepts/observation) | fact | follows | one version of a content item as read; the same version read again makes no second observation |
| [ReadingOfMeasure](/concepts/readingofmeasure) | fact | follows | a measure read at a time; a score today and last week are two facts |
| [Claim](/concepts/claim) | fact | follows | an attribute of an entity, from one source, for a time |
| [Connection](/concepts/connection) | fact | follows | a connection with any number of members, one row for the connection and one for each member |
| [ConnectionMember](/concepts/connectionmember) | value | none | one member of a connection, with its role |
| [KindOfConnection](/concepts/kindofconnection) | row | platform | a kind of connection, as a row: its roles and what each role allows |
| [ConnectionRole](/concepts/connectionrole) | value | none | a role a member may play |
| [HeaderRule](/concepts/headerrule) | value | none | how a kind of connection is read off the shared silver header: each role bound to one header column, and the rows the rule applies to |
| [MarketEvent](/concepts/marketevent) | fact | follows | something that happened to an entity in the market |
| [KindOfMarketEvent](/concepts/kindofmarketevent) | row | platform | a kind of market event |
| [Concept](/concepts/concept) | definition | follows | a named meaning a predicate may name; never a phrase |
| [Vector](/concepts/vector) | fact | follows | a vector from a model that carries meaning, named by its model; never a hash |
| [Deepening](/concepts/deepening) | work | follows | depth asked for one observation, with the reason it stopped |
| [FillOfMeaning](/concepts/fillofmeaning) | work | follows | the fill of quantized embeddings for one partition |
| [CatalogueEntry](/concepts/catalogueentry) | definition | follows | the only way to read a file of the lakehouse |
| [LakeFile](/concepts/lakefile) | value | none | one file of a partition |
| [LandedArtefact](/concepts/landedartefact) | fact | follows | the artefact as the source gave it, keyed by its content hash |
| [ClosedPartition](/concepts/closedpartition) | fact | follows | a closed partition of the refined layer; final, with the hash of its rows |
| [PartitionHandover](/concepts/partitionhandover) | work | follows | what the engine hands the record |
| [Assignment](/concepts/assignment) | fact | strategy | which members a move touched and which it left alone, written before the first action |
| [ProxyMembership](/concepts/proxymembership) | fact | follows | a subject's membership in a proxy over a period, as a fact with its evidence: the verdict, the scale of association, and the likelihood where a band is calibrated |
| [TouchedBuckets](/concepts/touchedbuckets) | value | none | for one table of gold, the entity buckets an acceptance touched and the snapshot it made; a reader is stale when its read set meets them |
| [LakehouseStore](/concepts/lakehousestore) | value | none | the value of the parameter the address of the lakehouse's store: the folder of files, the catalogue's database address without a password, and the prefix of the lakehouse catalogue's schemas, one for each plane |
| [BucketCounts](/concepts/bucketcounts) | value | none | the value of the parameter the layout of a table keyed by an entity: the count of buckets each plane splits it into |
| [PageChange](/concepts/pagechange) | fact | follows | a market event of the kind page changed: what was added, removed or changed between two versions of a page, and the extracted fields that moved |



## identity


| object | kind | scope | description |
|---|---|---|---|
| [KindOfEntity](/concepts/kindofentity) | row | platform | a kind of entity, with its keys in order of trust and what may never be merged |
| [KeyRank](/concepts/keyrank) | value | none | one namespace of identifier, its rank of trust and the sources that supply it |
| [Entity](/concepts/entity) | entity | shared | a thing of the market that lasts |
| [Identifier](/concepts/identifier) | fact | follows | an identifier that names an entity; never removed when a handle changes |
| [Mention](/concepts/mention) | work | follows | a thing named in an observation, on its way to an entity |
| [IdentityDecision](/concepts/identitydecision) | fact | follows | same, new or review, with the chance and the evidence; a wrong one is never edited |
| [PossibleMatch](/concepts/possiblematch) | work | follows | two entities that may be one; they stay two until it is settled |
| [Merge](/concepts/merge) | fact | follows | one fact recording that two entities are one; it changes no other fact |
| [Parting](/concepts/parting) | fact | follows | a later fact that ends a merge, restoring both sides |
| [IdentityMethod](/concepts/identitymethod) | row | platform | a method of deciding identity, ready only after it is calibrated for its kind |
| [KeyFitness](/concepts/keyfitness) | fact | platform | how often a key is present, and how often two different things share a value |
| [Window](/concepts/window) | value | none | a window at both ends |



## rules_engine


| object | kind | scope | description |
|---|---|---|---|
| [Population](/concepts/population) | row | platform | what a predicate runs over, with the reader that serves it at each speed |
| [Operator](/concepts/operator) | row | platform | an operator or a comparator of the closed language, as a row |
| [OperatorSlot](/concepts/operatorslot) | value | none | one slot of an operator |
| [Predicate](/concepts/predicate) | definition | follows | the tree, of three forms, over a population; an edit is a new predicate |
| [PredicateNode](/concepts/predicatenode) | value | none | one node of a predicate: a group, a condition or an operator node |
| [NearnessBar](/concepts/nearnessbar) | value | none | the bars of one breadth: the least similarity the name channel accepts and the least nearness the meaning channel accepts |
| [ConceptBars](/concepts/conceptbars) | value | none | the meaning bars of one concept under the model the bars were measured under: the score at each breadth's share for that concept alone, so a leaf's breadth means the same share whatever its concept |
| [BarsOfNearness](/concepts/barsofnearness) | value | none | the value of the parameter *the bars of nearness*: the bars of each breadth, read by the grounding on every channel and by the compiler when a leaf names a breadth, through one resolver |
| [SubjectResolution](/concepts/subjectresolution) | fact | follows | what a subject stands for when the predicate is armed: names, keys and meaning |
| [PlaceARunsAt](/concepts/placearunsat) | row | platform | a place a predicate runs: the population it reads, what an admitted unit makes, and who owns it |
| [SpeedBudget](/concepts/speedbudget) | value | none | the budget of one speed of the preview: units and time |
| [PreviewBudgets](/concepts/previewbudgets) | parameter | platform | the budget of each speed of the preview, enforced at the preview and nowhere else |
| [PredicateBudgets](/concepts/predicatebudgets) | parameter | platform | how far a predicate may expand, how much state it may keep, how large it may be, how many semantic leaves a tenant may arm |
| [Proxy](/concepts/proxy) | definition | follows | an observable the record can read standing for a thing it cannot |
| [FacetKind](/concepts/facetkind) | row | platform | a kind of facet, a closed register a person extends by a row |
| [ControlResult](/concepts/controlresult) | value | none | a control and what it read |
| [ProxyStrength](/concepts/proxystrength) | value | none | the strength of a proxy, never one number |
| [Calibration](/concepts/calibration) | value | none | precision, recall and the undercount, by segment, with intervals |
| [Facet](/concepts/facet) | definition | follows | a proxy of the membership engine built by one procedure, with its four views |
| [FacetCandidate](/concepts/facetcandidate) | value | none | a candidate community of a facet |
| [LanguageScale](/concepts/languagescale) | definition | follows | a name and two or more poles, counted over a group's own writing by month; aggregate-only by rule |
| [Pole](/concepts/pole) | value | none | one pole of a language scale |
| [Monitor](/concepts/monitor) | definition | follows | an armed condition that makes matches |
| [MonitorAnswer](/concepts/monitoranswer) | value | none | a monitor's answer on one beat |
| [Catch](/concepts/catch) | fact | follows | a unit admitted by a predicate at a place, with the conditions and the words that admitted it |
| [ConditionMatch](/concepts/conditionmatch) | value | none | one condition that admitted a match |
| [Signal](/concepts/signal) | fact | follows | a match with its kind, what it is about, its evidence and its rank for this brand |
| [SignalSubject](/concepts/signalsubject) | value | none | what a signal is about |
| [KindOfSignal](/concepts/kindofsignal) | row | platform | a kind of signal: what it means, its population, its sources, and a floor for each of the four numbers of strength |
| [SignalStrength](/concepts/signalstrength) | view | none | coverage, freshness at the tenth percentile, precision where truth is known, and independent corroboration |
| [Summary](/concepts/summary) | fact | follows | a count, share, rank or ratio in one of three positions, never folded |
| [Ladder](/concepts/ladder) | definition | follows | ordered rungs, each written as the rung below with further conditions |
| [Rung](/concepts/rung) | value | none | one rung: a predicate with its own coverage, mapped to one of the seven stages |
| [MeasurementOfBars](/concepts/measurementofbars) | work | platform | one measurement of the bars of nearness under a model: the probes in use, the units read, the shares each breadth admits, and the bars written |
| [Stage](/concepts/stage) | row | platform | one of the fixed stages every rung maps to, in a set, the seven buying stages or the router's seven, so ladders join across verticals within a set |
| [SavedView](/concepts/savedview) | definition | follows | a view over the record, a predicate or a recipe, kept current on a beat, served as a table |
| [Column](/concepts/column) | value | none | one column of a served table |
| [AttributesInput](/concepts/attributesinput) | value | none | which population's attributes to read |
| [AttributeCount](/concepts/attributecount) | value | none | one attribute a population's units carry: its path, its plain name, how many units carry it and the value type that was read |
| [PopulationAttributes](/concepts/populationattributes) | view | none | the attributes a population's units carry, read from the units themselves in one bounded scan, so a composer offers only what the record holds and a strata choice rests on counts |
| [SampleUnit](/concepts/sampleunit) | value | none | one unit of a preview's sample, with the words that met the predicate |
| [SampleStratum](/concepts/samplestratum) | value | none | one stratum of a preview's sample: how many matched in it and how many are shown |
| [PreviewSample](/concepts/previewsample) | value | none | a representative sample of the units a predicate matched: at most the asked number, spread over the population's strata in proportion with at least one from each stratum that matched, chosen by the hash of the unit so the same predicate gives the same sample |
| [PreviewAnswer](/concepts/previewanswer) | value | none | the one typed answer of a preview, at any speed |
| [ChannelCoverage](/concepts/channelcoverage) | value | none | one channel's coverage in an answer |
| [PopulationStatement](/concepts/populationstatement) | value | none | the required statement of the population an answer was read over |
| [PartialAnswer](/concepts/partialanswer) | value | none | which bound was reached, what was dropped, and which way that biases the count |
| [Beat](/concepts/beat) | row | platform | when something runs again; one register and one scheduler |
| [Deadline](/concepts/deadline) | work | follows | one unit waiting on a window's end, judged again at that moment by the one evaluator, so a condition made true by nothing arriving still fires |
| [SqlBounds](/concepts/sqlbounds) | value | none | the value of the parameter the bounds of a statement through the SQL path: rows returned, time and memory |
| [BeatBudget](/concepts/beatbudget) | value | none | the beat's budget: the units a tick may evaluate and the definitions it may start; the rest wait for the next tick, oldest first, one tenant after another |
| [MonitorPass](/concepts/monitorpass) | work | platform | one pass of the beat that runs the armed monitors: every armed version read, the units of its place's population evaluated since the monitor's last answer, a catch written for each unit admitted at an observation not caught before, a signal ranked from each catch, and the monitor's last answer kept |
| [LeadPass](/concepts/leadpass) | work | platform | one pass of the beat that walks signals to leads: every rung of every kind of buyer bound to a brand run over its population, a candidate made or lifted for each entity a rung admits, judged when it holds what the qualifying rung asks, a lead made from a qualified candidate with its temperature, and each lead delivered inside the plan's limit or withheld at it with the count |
| [ProxyBasket](/concepts/proxybasket) | definition | follows | a named, versioned list of proxies with its scope, read together over a subject, a set or groups |
| [BasketCell](/concepts/basketcell) | value | none | one proxy against one group: the count, the share, the lift against the base rate and the negative control |
| [BasketReading](/concepts/basketreading) | fact | follows | a basket read over one subject, a set or groups, kept as a fact and armed over its population |



## sources


| object | kind | scope | description |
|---|---|---|---|
| [Source](/concepts/source) | row | platform | anywhere the market is read, with its rights and its role |
| [AccessMethod](/concepts/accessmethod) | row | platform | one access method for one source: its kind, transport, credential kind, proxy policy, depth, rate, politeness, cost and contract |
| [WayContract](/concepts/waycontract) | value | none | the contract of a way |
| [Connector](/concepts/connector) | row | platform | the code for one source's ways and actions, with what it declares; one package of rows plus one implementation (18 §2.1) |
| [KindOfReading](/concepts/kindofreading) | row | platform | one kind of reading a connector declares, ready only after the check against recorded samples |
| [KindOfAction](/concepts/kindofaction) | row | platform | one kind of action a connector declares, with its reach and its inverse |
| [ArgumentDeclaration](/concepts/argumentdeclaration) | value | none | one argument of a kind of action, and where its value may come from |
| [SourceObject](/concepts/sourceobject) | row | platform | one kind of thing a source holds, in the source's own words |
| [SourceField](/concepts/sourcefield) | value | none | a field of a source object |
| [SourceId](/concepts/sourceid) | value | none | an id of a source object: its namespace, whether it is stable, the field that carries it and how far it is stable |
| [SourceTime](/concepts/sourcetime) | value | none | a time of a source object, with what it means |
| [SourceLink](/concepts/sourcelink) | value | none | a link between source objects |
| [Mapping](/concepts/mapping) | row | platform | how a source object becomes a registered kind: an entity, a content item, a fact (a reading, a claim, a connection, a vector, a control result) or a definition; with its connections, identifiers, the two times and readings |
| [ListParent](/concepts/listparent) | value | none | the thing an item of a list belongs to (a comment's post, a reply's comment, an edition's newsletter): the item field that carries the parent's key, the parent's kind and key namespace, and the connection from the item to the parent with the role each takes |
| [ListMapping](/concepts/listmapping) | value | none | how the items of a list field become entities of a kind, each keyed by the first of its key paths that holds a value, with one connection of a registered kind between the object's own entity and each item |
| [MappingConnection](/concepts/mappingconnection) | value | none | a link that becomes a connection |
| [MappingIdentifier](/concepts/mappingidentifier) | value | none | an id that becomes an identifier |
| [UserProvidedContentKind](/concepts/userprovidedcontentkind) | row | platform | a kind of user-provided content, a file, a pasted list, a photo, a link: how it is read and what may join a shared entity |
| [InstalledConnector](/concepts/installedconnector) | definition | follows | a connector a tenant set up, ready only when its identity is ready and a probe has answered |
| [SignedInIdentity](/concepts/signedinidentity) | definition | tenant | an identity a person captured in a browser; the agent never types a password |
| [WatchedIdentity](/concepts/watchedidentity) | definition | tenant | a public entity to follow, as an armed monitor over it |
| [Lease](/concepts/lease) | fact | shared | the acquisition system's leave to a host to call one way as one identity at one rate |
| [Arming](/concepts/arming) | fact | follows | a definition pointing at a cell and raising its value |
| [DemandCell](/concepts/demandcell) | work | follows | one demand cell however many definitions arm it; no tenant and no strategy in its key, only its plane |
| [Shortfall](/concepts/shortfall) | work | platform | one pass of the beat that fills the shortfall: every wanted cell read, a deepening asked for each entity its predicate names on the cell's source, the cell planned, covered once every deepening is fetched, or not satisfiable with the reason when the source needs a held identity the tenant does not hold |
| [AcquisitionPlan](/concepts/acquisitionplan) | fact | follows | what one beat issued and declined, adding up to its budget |
| [DeclinedCell](/concepts/declinedcell) | value | none | a cell declined with its reason |
| [Ask](/concepts/ask) | work | follows | one ask of one way for one cell, with its cost, its risk and a deadline |
| [DemandStatement](/concepts/demandstatement) | value | none | the one crossing out to the acquisition system |
| [Contribution](/concepts/contribution) | value | none | one ask's contribution to a demand statement |
| [Job](/concepts/job) | work | follows | one run of a way in the acquisition system or the connector host |
| [Cadence](/concepts/cadence) | definition | platform | when the host reads, within politeness; set only by a demand statement |
| [Yield](/concepts/yield) | fact | follows | what a job returned for each unit of cost, with the host's measured rate and health |
| [Attainability](/concepts/attainability) | fact | follows | learned from jobs that failed: whether a thing can be reached |
| [Backfill](/concepts/backfill) | work | platform | one backfill of a source over a window, read in blocks with a ledger row (a Job) each: what it reads, by which way, at which code version, from a parse already made by the connector's own implementation where one is held, and how far it has got |
| [Coverage](/concepts/coverage) | view | none | what has been read, when and how deep, in three positions, each reading naming its basis |
| [CoverageReading](/concepts/coveragereading) | value | none | one reading of coverage |
| [CoverageGap](/concepts/coveragegap) | value | none | a cell wanted and not covered, with its value and the reason |
| [TransportKind](/concepts/transportkind) | row | platform | one way of connecting, with one shared client; a transport inside a connector is a defect |
| [Credential](/concepts/credential) | definition | follows | a held identity that is a key, a token, a certificate or a signed request; only in the secrets manager, never returned |
| [NetworkProxyProvider](/concepts/networkproxyprovider) | row | platform | a provider of network proxy exits, as a row and a credential; none is named in code |
| [NetworkProxyPool](/concepts/networkproxypool) | definition | platform | a pool of exits, ready or not ready with the reason; over its ceiling, its jobs are held |
| [ProxyPolicy](/concepts/proxypolicy) | value | none | how one way routes: which pool kind, whether the exit sticks to the held identity, the country, and which failure classes rotate the exit |
| [SyncOffer](/concepts/syncoffer) | value | none | a pairing a connector offers: which kind of reading with which kind of action, over which identity link |
| [SyncRule](/concepts/syncrule) | definition | follows | one way or two ways from the same rows: pull arms cells, push runs as a move, a conflict is decided by the rule |
| [PushMapping](/concepts/pushmapping) | value | none | a record attribute written to a source field |
| [CaptureRule](/concepts/capturerule) | definition | tenant | a person's rule for the capture extension on one platform: on their say-so, every page under a named way, or never |
| [BronzeObject](/concepts/bronzeobject) | fact | follows | an artefact as the source gave it, keyed by its content hash, with the way it came by, the job, the time and the hop stamp; the bytes sit beside the row in the engine's own column, never in the row |
| [Capture](/concepts/capture) | fact | tenant | a page as a person saw it, with the source objects made from it, the neighbourhood the mapping's links define, and the trail |
| [ActionAudit](/concepts/actionaudit) | fact | follows | one row per action run through a connector: the move, the grant, the identity that served it, the arguments' sources, the source's own id for what was done, and the inverse |
| [RebuildRun](/concepts/rebuildrun) | work | follows | bronze replayed through refine and accept at one code version; ready only when every partition's hash equals the live run's |
| [SearchRequest](/concepts/searchrequest) | value | none | one metasearch query through the self-hosted SearXNG, fanned out across engines |
| [SearchResult](/concepts/searchresult) | value | none | one result of a metasearch, an observation with its source, its time basis and the engines that returned it |
| [ResourceFilter](/concepts/resourcefilter) | value | none | what a read may download and what it must not: resource types allowed and denied, size caps, address patterns, and whether to render |
| [ContentRequest](/concepts/contentrequest) | value | none | get_content: one address read as the person or the platform, with what to return and what may be downloaded |
| [ExtractedArticle](/concepts/extractedarticle) | value | none | the main content of a page as the carried extractor returns it: title, author, published time with its basis, language, word count, the extractor used and its quality score |
| [FieldSpec](/concepts/fieldspec) | value | none | one field of an extraction: its name, how it is found (a CSS selector, an XPath, a regular expression, a JSON path), the attribute read, its type, whether many, and nested fields |
| [CrawlScope](/concepts/crawlscope) | value | none | what a scrape may walk: the seeds, the address patterns allowed and denied, the greatest depth and count of pages, whether the sitemap drives discovery, and the pagination rule |
| [DenyHost](/concepts/denyhost) | row | platform | a host whose addresses a capture turns away, the one list that does: a tracker, an advertising pixel or a malicious host, named by a person, never a guess; every other address a walk discovers is queued as a capture of its own, because nothing a capture reaches is out of scope |
| [ScrapeRequest](/concepts/scraperequest) | value | none | arbitrary scraping as data: a scope, an extraction of fields or a schema for the model-assisted reader, the source object the rows become, a resource filter, a held identity and a proxy policy |
| [NormalisationRule](/concepts/normalisationrule) | value | none | how one extracted field becomes a typed value: trimmed text, a number with its unit, money with its currency, a date with its basis, a regular-expression capture, a map of words to a registered kind, or an entity looked up by identifier |
| [ExtractionTemplate](/concepts/extractiontemplate) | definition | follows | the scraping framework's unit: what a page kind looks like, how far to walk, how to render and navigate, what to extract, how each field is normalised, what makes a row the same row, which source object and mapping the rows become, under which policies, proved by recorded samples |
| [ScrapeRun](/concepts/scraperun) | work | follows | one run of an extraction template or of an inline scope: pages walked and denied, rows made, bytes, cost and time, with partial results at block boundaries; a whole site's crawl from its sitemap is one run |
| [ScrapeResult](/concepts/scraperesult) | view | none | the rows a scrape made, each a source object with its evidence span, the pages walked, what the filter denied, and the hops |
| [SiteWatch](/concepts/sitewatch) | definition | follows | a watched identity over a site: its page set and sitemap, its cadence through demand cells, the extraction applied to each page, the conditions that make a change a signal, and the channels told |
| [ContentResponse](/concepts/contentresponse) | value | none | what get_content returned: each requested form, the article's fields where asked, the artefact's hash in bronze, the bytes by resource type, and the identity that served it |
| [BrowsingSession](/concepts/browsingsession) | work | follows | a browser of the pool the agent or a person drives step by step through the controlled API, with a live view; never a raw browser over the network |
| [BrowsingStep](/concepts/browsingstep) | value | none | one step in a browser, the agent's in a browsing session or the person's own as the extension saw it under a capture rule: navigate, read, click, type, select, submit, scroll, wait, screenshot, download, close; a step that submits or sends is an action with a reach |
| [StepPage](/concepts/steppage) | value | none | the page after a browsing step that asked for a light reading: its address and its title, without a reading of the whole page |
| [DownloadJob](/concepts/downloadjob) | work | follows | one file of a download set through the download manager: resumable by byte range, pausable, bounded by residency, landing in bronze or the person's workspace |
| [RuntimeContext](/concepts/runtimecontext) | value | none | one of the extension's six runtime contexts: what it may do and what it never does |
| [ExtensionSession](/concepts/extensionsession) | value | none | the extension's sign-in: the person, the tenant, the token's expiry, the transport in use and the contract hash the server reports |
| [PageProperty](/concepts/pageproperty) | value | none | one property a page template read: its name, its label, its value, where it came from and, for a list, how many items it holds |
| [PageContact](/concepts/pagecontact) | value | none | one contact a page showed, by a contact kind: the value as shown, the value as identity compares it, and where it came from |
| [PageMiss](/concepts/pagemiss) | value | none | one template field a reader could not read: what it should have been and what the page showed where it was expected |
| [PageLink](/concepts/pagelink) | value | none | one visible link of a page |
| [PageLayer](/concepts/pagelayer) | value | none | a dialog, menu or viewer open on the page when it was read, read as its own region: its kind, its title, the visible text, its links and how many items it listed; what a reveal of the domain binds to |
| [PageHints](/concepts/pagehints) | value | none | how a page was read and what was kept out |
| [Annotation](/concepts/annotation) | value | none | one thing a person states about a subject of the record, from any face: the capture panel while a page is captured, the web shell or the desktop shell on an entity's page, the agent in a conversation, or the API. What it is about is the page's subject, an item of a list, a contact, a region picked on the page, or an entity named by its id; what is said is a tag from one of the record's registers, a fit for a buyer profile, a relation to an entity the record holds, a membership, a rival marking, a note, or what kind of thing the subject is. It becomes a claim or a connection stated by the person, with the capture or the conversation as its evidence, through the one placing rule of the accept, whichever face said it |
| [PageField](/concepts/pagefield) | value | none | one form field a page showed, with what it held when the page was read: its label, its name, its kind, its value, and whether the person changed it; a password, a one-time code and a card's number never appear, by the platform's redaction rows |
| [PageMeasure](/concepts/pagemeasure) | value | none | one count a page showed, read as a registered kind of measure: likes, comments, views, stars, downloads, followers, applicants and every other engagement a page shows, with the number as shown and as a number, and where it came from; it becomes a reading of the measure on the page's subject |
| [PageNetworkEvent](/concepts/pagenetworkevent) | value | none | one call the page made or one frame it received while a capture rule was on, as the page hook in the main world saw it: its kind, its method and address, the status, and the bodies sent and received, cut to a bound; never a header, a cookie or a credential |
| [PageReading](/concepts/pagereading) | value | none | a page as a reader read it, the document a capture carries and a walk deposits: the address, the title, the visible text, the headings and links, the properties the template read, the contacts the page showed, the fields not read, the template, and how it was read; the extension and the walk make the same shape |
| [ContactKind](/concepts/contactkind) | row | platform | one way a person or a company is reached or found anywhere on the web, as the extension reads it on every page and the accept keys it: an email, a phone, a handle on a platform, an invite, a site; found by the addresses of links, by a pattern over the visible text, or by a bare handle near a cue word; it becomes an identifier of the namespace the row names |
| [CaptureDeclaration](/concepts/capturedeclaration) | row | platform | what the extension keeps on one platform or domain, as one row of the browser connector, parameterized by the platform: address patterns, the network events to keep, the visible links, the scopes and the redactions |
| [RedactionRule](/concepts/redactionrule) | row | platform | what never leaves the browser: a field, a header, an address key or a pattern in the body, applied before hashing |
| [CapturePreview](/concepts/capturepreview) | view | none | what a capture would send: bytes by kind, network events kept and dropped, redactions by kind, the neighbourhood's size, the cells credited and what the plan meters |
| [MentionKind](/concepts/mentionkind) | row | platform | what kind of thing a page's property names, so the grounding knows a page's author is an account and its employer a company: one row per property, for every platform or the ones listed; a template's field whose type names a kind of entity overrides it, and the person's settled words on each property and platform are read as its priors |
| [PlatformThing](/concepts/platformthing) | value | none | one kind of thing a platform holds, in the platform's own words, and the registered kind it becomes: its key on the platform, the fields kept as long texts, the fields that are outbound links, and the counts it shows |
| [PlatformRelation](/concepts/platformrelation) | value | none | one way two things of a platform relate, and the registered kind of connection it becomes with the role each side takes |
| [PlatformListParent](/concepts/platformlistparent) | value | none | the thing an item of a list belongs to, in the platform's words: the item field that carries the parent's key, the parent thing, and the relation from the item to it |
| [PlatformList](/concepts/platformlist) | value | none | a list a page or an API answer carries whose items are things of the platform, each keyed by the first of its key paths that holds a value, and the relation between the page's thing and each item |
| [PlatformPage](/concepts/platformpage) | value | none | one kind of page of a platform: what it yields, how it is read, the lists it carries, whether it pages through a next link, and what the viewer must be to see it |
| [PlatformReveal](/concepts/platformreveal) | value | none | one control on a kind of page that shows more without leaving it, or leads to the page that holds the rest: what a person clicks, what opens, where what opens is drawn from (the page's own data, another page of the domain, an API object the click calls, or nothing kept), the fields and lists read inside it, and what the viewer must be to see it; a reveal is how a capture taken with a dialog open, or a step the person took, is bound to the domain |
| [PlatformApiObject](/concepts/platformapiobject) | value | none | one object of a platform's API: the addresses that answer it, what it yields, the paths read from its JSON and the lists it carries |
| [PlatformMention](/concepts/platformmention) | value | none | what kind of thing a property names on this platform |
| [PlatformSignal](/concepts/platformsignal) | value | none | a signal kind the platform's things, relations or measures feed, with what on the platform means it |
| [PlatformDomain](/concepts/platformdomain) | row | platform | a platform's world as one row the capture side is generated from: its things and the kinds they become, how they relate, its pages and its API objects with what each yields and the lists each carries, what its properties name, and what feeds a signal; the platform's sources, the browser connector's declaration, the source objects, the templates, the mappings and the mention kinds are derived from this row by the authoring tool and never written beside it |
| [SessionMaterial](/concepts/sessionmaterial) | value | none | the session material a signed-in identity of one platform holds and the read that proves it: the cookie domains the platform keeps, the address whose answer differs signed in from signed out, and the text that appears only when signed in |
| [HeldCookie](/concepts/heldcookie) | value | none | one cookie of a held identity's session state, as the browser gave it |
| [SessionState](/concepts/sessionstate) | value | none | the session state a held identity keeps in the store, checkpointed after each use: the cookies of the platform's cookie domains and when it was checkpointed |
| [HeldSessionState](/concepts/heldsessionstate) | definition | tenant | the session state of a held identity, sealed with the identities' key and kept in the record, so that every copy of the platform reads one store; the key never enters the record, and no tool returns this row |
| [Grounding](/concepts/grounding) | work | follows | the grounding of one subject, a captured page, an entity, a text or an address: its mentions resolved and its relations suggested as hypotheses a person settles; staged when the subject is given, waiting for a person once the hypotheses are made, committed when every one is settled; the same work on every face |
| [PendingCapture](/concepts/pendingcapture) | value | none | a capture the extension holds until the core accepts it: keyed like the capture, with its bytes, attempts and state |
| [SourceColumn](/concepts/sourcecolumn) | value | none | one column of a table of a read artefact, as the engine names it |
| [SourceTable](/concepts/sourcetable) | value | none | one table of a read artefact: its count with its exactness, its population and the control that must come back right at the same hash |
| [SourceJoin](/concepts/sourcejoin) | value | none | one join from a table of a read artefact to another source, by an identifier |
| [SourceProcedure](/concepts/sourceprocedure) | row | platform | how a source is read, derived from its row and its last reading: how it opens, every table with its count, population and control, the joins, the lineage and the pitfalls |
| [HeldArtefact](/concepts/heldartefact) | value | none | the value of the parameter the artefacts on this machine: one lake, catalogue or folder of files still outside the one lakehouse, read in place until its tables are mapped in, with the name the engine opens it under, the registered source its tables derive from, its path, the program that made it and the repository whose commit the reading records |
| [BrowseView](/concepts/browseview) | view | none | one frame of a browsing session's page as the person sees it, with the page's size and address, read by a dashboard that shows the session live and forwards the person's clicks and words as steps; never a raw browser over the network |



## operations


| object | kind | scope | description |
|---|---|---|---|
| [KindOfUsage](/concepts/kindofusage) | row | platform | one kind of metered usage with its unit, its price basis and its provider: network egress, proxy bytes, model tokens, embedding calls, image generation, document storage, lakehouse bytes, browser minutes, search queries, connector calls, downloads |
| [MeteredUsage](/concepts/meteredusage) | fact | follows | one row per metered call, written by the metering middleware in the same unit of work as the call; a call whose row cannot be written does not complete |
| [UsageReconciliation](/concepts/usagereconciliation) | fact | follows | the metered total against the provider's bill for one day, with the count and sum of discrepancies; ready only under the tolerance |
| [RunningService](/concepts/runningservice) | work | platform | a service of the platform, with its life |
| [HealthCheck](/concepts/healthcheck) | row | platform | a signal that can fail, its vacuity guard, and where it runs |
| [Alarm](/concepts/alarm) | row | platform | the law or the level it reads, the threshold, who is told, the runbook |
| [AlarmRaising](/concepts/alarmraising) | work | platform | one raising of an alarm |
| [Backup](/concepts/backup) | work | platform | the daily verified backup of the database, with the lakehouse's catalogue and manifest beside it |
| [RestoreDrill](/concepts/restoredrill) | work | platform | a backup restored into a throwaway target, with the time it took and the count that must match |
| [Trail](/concepts/trail) | view | platform | every access and every administrator's change, with the hash chain over it |
| [CostCeiling](/concepts/costceiling) | parameter | platform | money a month by kind, and the share at which an alarm is raised |
| [Incident](/concepts/incident) | work | platform | what was seen, the reading that found it, what was done, what changed, and the check added |
| [Price](/concepts/price) | value | none | the price of one kind of usage under one plan kind: per unit, its currency, and the quantity the plan includes |
| [PriceList](/concepts/pricelist) | row | platform | the prices in force from a date, versioned; a change is a new version |
| [BillingAccount](/concepts/billingaccount) | row | tenant | the tenant's account with the payment provider: the provider's customer id, the currency, the address, the payment state, the period |
| [Invoice](/concepts/invoice) | fact | tenant | one invoice: the lines by kind of usage from the metered rows, the fee, the amount recomputed from the record, the provider's id and the state |
| [UsageStatement](/concepts/usagestatement) | view | none | a tenant's metered usage of a period by kind, priced, against the plan's included quantities |
| [EngineExtension](/concepts/engineextension) | definition | platform | one extension of the query engine, pinned by version and hash as a row of the release, shipped with it and never fetched at run time |



## harness


| object | kind | scope | description |
|---|---|---|---|
| [UsageInput](/concepts/usageinput) | value | none | usage by tenant, kind, provider and window, for platform administrators |
| [UsageReport](/concepts/usagereport) | view | none | quantity and cost by kind, by tenant, by provider and by period, with each provider's reconciliation state |
| [Tool](/concepts/tool) | row | platform | a capability from the tool register, with its inputs and outputs as owning types; generated, never written by hand |
| [Workflow](/concepts/workflow) | definition | strategy | steps and what starts them, the same object whether a person or the agent composed it |
| [WorkflowStep](/concepts/workflowstep) | value | none | one step: a tool to run, a wait, a branch on a predicate, or another workflow |
| [Run](/concepts/run) | work | strategy | one carrying out of a workflow; every step durable work keyed by the run, the step and its input |
| [StepResult](/concepts/stepresult) | value | none | one step's result, kept so a second pass reads it back and never asks again |
| [Task](/concepts/task) | view | none | a run a caller started through a tool: its progress, what it asks, and how it ended |
| [ReleaseStamp](/concepts/releasestamp) | value | none | which release a running binary is: the platform's semantic version, the commit it was built from with its time, whether the build had changes beyond the commit, and the contract it carries; every process reports it in its handshake, its --version, its first log line and the client name on every event it writes, so a report of a defect names the build and the build names the change |
| [EndpointHolder](/concepts/endpointholder) | value | none | the process that serves the durable engine's endpoint on this machine, written beside the stack: its process id, the hash of the binary it runs, its release, its port and when it started; a newer release takes the endpoint over from an older one, the same release shares it, and an older one never takes it back |
| [Progress](/concepts/progress) | value | none | steps done of steps in all, and what the task waits for |
| [TaskQuestion](/concepts/taskquestion) | value | none | a question a run asks the caller; answering it is the one approval |
| [Notification](/concepts/notification) | work | user | a message that something needs a person, with the tool that resolves it |
| [Card](/concepts/card) | value | none | the one result of every tool: a typed value, its foot, and what can be done next; it cannot be built without its foot |
| [CardFoot](/concepts/cardfoot) | value | none | what was read, the population, the control with what was expected and what was seen, and the position of each count |
| [NextAction](/concepts/nextaction) | value | none | what can be done next from a card |
| [Memory](/concepts/memory) | fact | follows | a decision, a preference, a correction or a standing instruction, at strategy or user scope; never a permission |
| [NamedProcedure](/concepts/namedprocedure) | definition | platform | a written way of doing a recurring job, which the agent follows and a person can read |
| [Workbench](/concepts/workbench) | definition | strategy | a place to run queries, and later code, over what the caller may read, through the tools |
| [Thread](/concepts/thread) | work | strategy | the durable container of one conversation between a user and the agent; created, resumed, forked and archived; its history is the event log |
| [Turn](/concepts/turn) | work | strategy | one unit of the agent's work, started by one input and ended when its outputs are produced; it holds items in order |
| [Item](/concepts/item) | value | none | the atomic unit of input and output on the wire, typed by kind, with a lifecycle of started, streaming and completed; a tool call completes with its response card |
| [ApprovalRequest](/concepts/approvalrequest) | value | none | a request the server raises when the permission check's verdict is propose: the action, its inverse, the verdict and the reason; the turn waits for the client's answer |
| [ClientInfo](/concepts/clientinfo) | value | none | what a client states about itself in the handshake |
| [ServerInfo](/concepts/serverinfo) | value | none | what the app server returns in the handshake: its user agent, the protocol version, the contract hash and its capabilities |
| [EventCursor](/concepts/eventcursor) | value | none | the position in the event log a client has rendered to; a reconnecting client sends it and receives every event after it |
| [ProcedureResult](/concepts/procedureresult) | value | none | what one run of a named procedure in the workbench left: the procedure, the run, the hashes of its code and its inputs, its outputs as measures, how it ended and how long it took |
| [UserMessage](/concepts/usermessage) | value | none | what a person typed into a turn |
| [AgentMessage](/concepts/agentmessage) | value | none | the words the agent answers a turn with, from the model row that served |
| [ToolCall](/concepts/toolcall) | value | none | one call of a tool inside a turn: the tool, its inputs, and what it became, a card or a refusal |
| [ToolMeta](/concepts/toolmeta) | value | none | what a listed MCP tool carries beside its schema: its row as the register holds it and the release's stamp |
| [CallEnvelope](/concepts/callenvelope) | value | none | what every call carries beside its input: the scope, the two dates for a read, and for a change the key made from the input |
| [UnitRef](/concepts/unitref) | value | none | one unit by its id and kind |
| [Nothing](/concepts/nothing) | value | none | an input with no fields |
| [GrantsInput](/concepts/grantsinput) | value | none | the caller, and a place |
| [SignOutInput](/concepts/signoutinput) | value | none | the session, or the user for every session |
| [WhoAmIInput](/concepts/whoamiinput) | value | none | a token, a key, or a run's identity |
| [SignInInput](/concepts/signininput) | value | none | nothing, or the tenant to sign in to; or an access token the identity provider issued, which a browser or an agent presents to the face it is connected on |
| [CacheInput](/concepts/cacheinput) | value | none | nothing, or a call to forget |
| [CacheView](/concepts/cacheview) | view | none | what the app holds from earlier answers |
| [CacheEntry](/concepts/cacheentry) | value | none | one cached answer |
| [FactsInput](/concepts/factsinput) | value | none | a unit or a population, as of two dates |
| [FactsAnswer](/concepts/factsanswer) | view | none | the facts, and the tier that gave them |
| [GroupsInput](/concepts/groupsinput) | value | none | a scope, the two dates, and the resolution of the cut |
| [KeepQuestionInput](/concepts/keepquestioninput) | value | none | the question and its scope |
| [SemanticSearchInput](/concepts/semanticsearchinput) | value | none | a text or a subject's vector, the model, a floor and a population |
| [SemanticSearchAnswer](/concepts/semanticsearchanswer) | view | none | the units above the floor, with the model, the floor, the measured recall of quantized embeddings, and the tier |
| [ScoredUnit](/concepts/scoredunit) | value | none | a unit with its nearness |
| [NeighboursInput](/concepts/neighboursinput) | value | none | an entity, one kind of connection, and the two dates |
| [NeighboursAnswer](/concepts/neighboursanswer) | view | none | the members one hop away, and whether the cap was reached |
| [PreviewInput](/concepts/previewinput) | value | none | a predicate or its hash, the place, the window, the speeds wanted, and the surface it calls from |
| [SavedViewInput](/concepts/savedviewinput) | value | none | a view to keep, or a view to read |
| [SavedViewAnswer](/concepts/savedviewanswer) | view | none | the definition, or its rows with when they were built |
| [SqlInput](/concepts/sqlinput) | value | none | a read-only query, in a strategy |
| [SqlAnswer](/concepts/sqlanswer) | view | none | rows, with how many and whether a bound was reached |
| [LocalInput](/concepts/localinput) | value | none | a question in one of the ask tools' owning types, over the files the app may read |
| [AudienceMapInput](/concepts/audiencemapinput) | value | none | a brand, two facets or a facet and a community, the window |
| [CandidatesInput](/concepts/candidatesinput) | value | none | a brand, and a buyer profile or a place |
| [CompareInput](/concepts/compareinput) | value | none | two brands and a question from the closed list |
| [Comparison](/concepts/comparison) | view | none | two summaries over one structure, each with its coverage |
| [ConnectorsInput](/concepts/connectorsinput) | value | none | a tenant or a brand |
| [ConnectorOffer](/concepts/connectoroffer) | view | none | every kind of reading and of action, by source, with its state, the identity it needs, its cost and its rights |
| [ConsentInput](/concepts/consentinput) | value | none | the person or tenant, and the use; to record, withdraw or ask |
| [ConsentAnswer](/concepts/consentanswer) | view | none | a fact, or yes or no with the fact that decides |
| [CoverageInput](/concepts/coverageinput) | value | none | a cell, or a scope of entities with a window |
| [DocumentInput](/concepts/documentinput) | value | none | the document and the version |
| [DocumentChangesInput](/concepts/documentchangesinput) | value | none | two versions of one document |
| [EffectInput](/concepts/effectinput) | value | none | a move and the window |
| [EntityInput](/concepts/entityinput) | value | none | an entity, and the two dates |
| [EntitySurface](/concepts/entitysurface) | view | none | every identifier it ever had, every account, everything it published, every thread, community and gathering, and every connection |
| [EstimateInput](/concepts/estimateinput) | value | none | an estimator and the case |
| [ForecastsInput](/concepts/forecastsinput) | value | none | a play or a tactic, across brands |
| [ForecastsAnswer](/concepts/forecastsanswer) | view | none | every forecast with its effect, how well the band held, and the proper score and the calibration by play, tactic, kind of buyer, framing, actor and content, so calibration is a read of this row and never a report of its own |
| [ForecastAndEffect](/concepts/forecastandeffect) | value | none | one forecast and its effect |
| [ScoreBySegment](/concepts/scorebysegment) | value | none | the proper scores and the calibration of the forecasts of one segment: a play, a tactic, a kind of buyer, a framing, an actor or a content |
| [LeadsInput](/concepts/leadsinput) | value | none | a brand, and a place, a condition or a person; or one lead as its package |
| [LedgerInput](/concepts/ledgerinput) | value | none | a strategy and the window |
| [Ledger](/concepts/ledger) | view | none | every move, action, forecast, effect and impact in order, with the budget spent by kind |
| [LookupInput](/concepts/lookupinput) | value | none | a key: a namespace with a value, or a name with a place |
| [LookupAnswer](/concepts/lookupanswer) | view | none | the entity, or the possible matches, or nothing |
| [MapInput](/concepts/mapinput) | value | none | a brand, and the two dates |
| [MarketInput](/concepts/marketinput) | value | none | a brand, a segment, the window |
| [MonitorStrengthInput](/concepts/monitorstrengthinput) | value | none | the monitor and a window |
| [ParameterInput](/concepts/parameterinput) | value | none | a parameter by name and where it is set |
| [PostureInput](/concepts/postureinput) | value | none | a community and the window |
| [PredicateLanguage](/concepts/predicatelanguage) | view | none | the operators, the comparators and the value types, with the hash |
| [ProxyReadInput](/concepts/proxyreadinput) | value | none | a proxy, and the window |
| [ProxyReading](/concepts/proxyreading) | view | none | its members as a population, with the raw count, the estimate corrected by the undercount, and the interval |
| [RegisterInput](/concepts/registerinput) | value | none | a register by name, or a name to check |
| [RegisterAnswer](/concepts/registeranswer) | view | none | its rows and the hash, or one row or nothing |
| [RolesInput](/concepts/rolesinput) | value | none | nothing, or one role |
| [SignalsInput](/concepts/signalsinput) | value | none | a monitor, a subject, a kind or a strategy, and a window |
| [SignalsAnswer](/concepts/signalsanswer) | view | none | the facts, with the coverage and the count not evaluable for the same window |
| [SpeedToLeadInput](/concepts/speedtoleadinput) | value | none | a brand and a window |
| [UnderTestInput](/concepts/undertestinput) | value | none | a unit, a brand or a scope |
| [VerticalInput](/concepts/verticalinput) | value | none | the vertical, or a brand whose vertical is meant |
| [WhyInput](/concepts/whyinput) | value | none | a unit that is not ready, or a count that is not measured |
| [WhyAnswer](/concepts/whyanswer) | view | none | the chain of reasons, from this unit back to its first cause |
| [Reason](/concepts/reason) | value | none | one link of a chain of reasons |
| [WithheldInput](/concepts/withheldinput) | value | none | a brand or a tenant, and the period |
| [StocksInput](/concepts/stocksinput) | value | none | a scope, and optionally one kind |
| [JourneyInput](/concepts/journeyinput) | value | none | one unit, and a bound on depth |
| [OldestInput](/concepts/oldestinput) | value | none | a place |
| [PairingsInput](/concepts/pairingsinput) | value | none | a scope |
| [PairingsAnswer](/concepts/pairingsanswer) | view | none | each pairing, with the units that lack their pair |
| [PairingReading](/concepts/pairingreading) | value | none | one pairing and the units that lack their pair |
| [WaitingInput](/concepts/waitinginput) | value | none | nothing, or a notification to acknowledge |
| [CapabilitiesPage](/concepts/capabilitiespage) | view | none | the page of capabilities |
| [ArmMonitorInput](/concepts/armmonitorinput) | value | none | the monitor's version, and for arming the preview it was judged by |
| [JudgeFitInput](/concepts/judgefitinput) | value | none | a kind of buyer and an entity to judge, without making a lead |
| [BuyerFitVerdict](/concepts/buyerfitverdict) | view | none | the fit with its criteria, its temperature and its verdict |
| [KeepLadderInput](/concepts/keepladderinput) | value | none | a ladder to keep: its ordered rungs, each a predicate over the population that is kept by its hash in the same call, and the rung that qualifies |
| [KeepMonitorInput](/concepts/keepmonitorinput) | value | none | a monitor to keep: its name, its predicate, the place it runs at and the kind of signal it makes; the strategy where one is chosen, else the brand's standing strategy; for a platform monitor the vertical it keeps full |
| [KeepPlayInput](/concepts/keepplayinput) | value | none | a play to keep for a brand: the play with its condition and its graph of moves as edges, and the predicates given in full, kept by their hashes before the play |
| [ArmPlayInput](/concepts/armplayinput) | value | none | the play, inside a strategy, for a brand, and the share it is armed on with its holdout: a share under one makes the play an experiment |
| [ArmPlayAnswer](/concepts/armplayanswer) | view | none | the armed play, and the cells of demand it raised |
| [AssignInput](/concepts/assigninput) | value | none | the lead and the user; by hand, or hand on |
| [BeatInput](/concepts/beatinput) | value | none | a beat to write |
| [KeepBuyerInput](/concepts/keepbuyerinput) | value | none | a buyer profile as it should stand next: its own predicate in full, its bindings and its ladder; the platform compiles the predicate, keeps it by its hash, and writes the next version ready or not ready with the reason |
| [BindBuyerInput](/concepts/bindbuyerinput) | value | none | a buyer profile and its bindings |
| [BindBuyerAnswer](/concepts/bindbuyeranswer) | view | none | the binding, and the preview of the kind's members |
| [BuildDocumentInput](/concepts/builddocumentinput) | value | none | a document, as of two dates |
| [CapacityInput](/concepts/capacityinput) | value | none | a user, how many, and the period |
| [CorrectInput](/concepts/correctinput) | value | none | the event to correct, and the correction |
| [DecideAskInput](/concepts/decideaskinput) | value | none | an ask, approved or declined |
| [DecideMoveInput](/concepts/decidemoveinput) | value | none | accept, decline or stop a move |
| [DeepenInput](/concepts/deepeninput) | value | none | an observation and the depth asked |
| [DryRunInput](/concepts/dryruninput) | value | none | an action to dry run |
| [DryRunAnswer](/concepts/dryrunanswer) | view | none | what it would do, and what the inverse would be |
| [GoalInput](/concepts/goalinput) | value | none | a goal to add |
| [GrantInput](/concepts/grantinput) | value | none | give, change or withdraw a grant |
| [InstallConnectorInput](/concepts/installconnectorinput) | value | none | the connector, the ways, the identity and the settings |
| [InstallPackInput](/concepts/installpackinput) | value | none | a brand, the template and its version |
| [InstallPackAnswer](/concepts/installpackanswer) | view | none | the copies made, each naming its origin |
| [KeepProxyInput](/concepts/keepproxyinput) | value | none | a proxy to keep |
| [MapBrandInput](/concepts/mapbrandinput) | value | none | a web address, and the tenant it is mapped for |
| [MakeBrandDesignSystemInput](/concepts/makebranddesignsysteminput) | value | none | the brand whose design system is made from the pages held on its site |
| [BrandDesignSystemInput](/concepts/branddesignsysteminput) | value | none | the brand, and the version wanted, else the newest |
| [DecideBrandDesignInput](/concepts/decidebranddesigninput) | value | none | a decision on one value of a brand's design system |
| [BrandDesignSystemChangesInput](/concepts/branddesignsystemchangesinput) | value | none | the brand and two versions, else the two newest |
| [MarkLeadInput](/concepts/markleadinput) | value | none | the lead, the condition, and a reason where the condition asks for one |
| [MarkRivalInput](/concepts/markrivalinput) | value | none | a brand and the rival, with the evidence |
| [MembershipInput](/concepts/membershipinput) | value | none | invite, suspend or remove a user, as a member or a guest |
| [ProposeMoveInput](/concepts/proposemoveinput) | value | none | a play and the catch, or the play's schedule |
| [PublishInput](/concepts/publishinput) | value | none | a build and an address |
| [RaiseNeedInput](/concepts/raiseneedinput) | value | none | a demand cell to raise |
| [RememberInput](/concepts/rememberinput) | value | none | a memory to keep, or one to forget |
| [RoutingInput](/concepts/routinginput) | value | none | a routing rule to write, preview or arm |
| [RoutingAnswer](/concepts/routinganswer) | view | none | the rule; for a preview, which leads it would have admitted and who would have had them |
| [RunActionInput](/concepts/runactioninput) | value | none | an action to run |
| [ParameterWriteInput](/concepts/parameterwriteinput) | value | none | a parameter of the record written from the console or by a person's own tool: its name, its value and the scope it is set at |
| [GroundInput](/concepts/groundinput) | value | none | a subject to ground at a breadth: exactly one of a capture, an entity, a text or an address; the same grounding serves the capture panel, the entity page of the web and desktop shells, the agent and the API |
| [GroundingsInput](/concepts/groundingsinput) | value | none | which groundings to read: one capture's, one entity's, or every one in a place |
| [GroundingAnswer](/concepts/groundinganswer) | view | none | a grounding with its hypotheses, each with what it proposes |
| [GroundingPriorsInput](/concepts/groundingpriorsinput) | value | none | the priors of grounding: one platform's, or every platform's |
| [GroundingPrior](/concepts/groundingprior) | value | none | how often a person supported a kind of suggestion on a platform at a breadth |
| [GroundingPriors](/concepts/groundingpriors) | view | none | the priors, one row per kind, platform and breadth |
| [TrajectoryInput](/concepts/trajectoryinput) | value | none | a strategy's or one move's trajectory over a window |
| [MoveTrajectory](/concepts/movetrajectory) | value | none | one move: its place, the items that carried it out, the readings of those items and its effect |
| [Trajectory](/concepts/trajectory) | view | none | plan item to grounded move to outcome, for each move in the window |
| [PlanReportInput](/concepts/planreportinput) | value | none | a strategy and a window |
| [PlanReportRow](/concepts/planreportrow) | value | none | one play of the strategy against what was done: completed, partial, missing, or an item done off any plan |
| [PlanReport](/concepts/planreport) | view | none | did I do what I planned: one row per play, then the items done off plan |
| [CaptureHealthInput](/concepts/capturehealthinput) | value | none | the health of capture on one platform or all, over a window against the window before |
| [CaptureHealthRow](/concepts/capturehealthrow) | value | none | one platform's captures in the window and the window before, with the verdict |
| [CaptureHealth](/concepts/capturehealth) | view | none | captures by platform, this window against the last |
| [SettleInput](/concepts/settleinput) | value | none | a claim under test, settled |
| [SettleMatchInput](/concepts/settlematchinput) | value | none | a possible match, confirmed or rejected |
| [SettleMatchAnswer](/concepts/settlematchanswer) | view | none | confirmed with the merge, or rejected |
| [StrategyInput](/concepts/strategyinput) | value | none | a strategy to make |
| [StrategyReadInput](/concepts/strategyreadinput) | value | none | a strategy to read, as of a date |
| [StrategyMoveInput](/concepts/strategymoveinput) | value | none | a strategy moved to a place in its life, with the reason |
| [PropensityInput](/concepts/propensityinput) | value | none | a lead, a move or a play, and which faces to read: actors, content or both |
| [PropensityAnswer](/concepts/propensityanswer) | view | none | every eligible actor and every fitting content with its propensity, and the one the policy would choose on each face |
| [PolicyReplayInput](/concepts/policyreplayinput) | value | none | a policy and its version replayed on a strategy's logged decisions over a window |
| [PolicyReplayRow](/concepts/policyreplayrow) | value | none | one logged decision: what was chosen with its odds, what the replayed policy would have chosen, and the effect that followed |
| [PolicyReplay](/concepts/policyreplay) | view | none | a policy replayed on the history before it changes anything |
| [UndoInput](/concepts/undoinput) | value | none | an action to undo |
| [UndoAnswer](/concepts/undoanswer) | view | none | the action undone, and the inverse's own action |
| [UndoMergeInput](/concepts/undomergeinput) | value | none | a merge to undo, or a decision to undo |
| [UndoMergeAnswer](/concepts/undomergeanswer) | view | none | a parting, or a later decision with the facts written again |
| [WatchInput](/concepts/watchinput) | value | none | a public entity to watch |
| [WebhookInput](/concepts/webhookinput) | value | none | an address to be told at, and the kinds |
| [WeighInput](/concepts/weighinput) | value | none | a claim and the evidence to attach |
| [WithdrawInput](/concepts/withdrawinput) | value | none | a publishing to withdraw |
| [WorkflowInput](/concepts/workflowinput) | value | none | a workflow to write, preview or arm |
| [WorkflowAnswer](/concepts/workflowanswer) | view | none | the workflow, and for a preview what it would have done over history |
| [BuildFacetInput](/concepts/buildfacetinput) | value | none | a facet to build from a seed |
| [CancelInput](/concepts/cancelinput) | value | none | a preview or a task to cancel |
| [RunRequest](/concepts/runrequest) | value | none | a run to make on the work plane: the workflow, the caller, the envelope and what started it |
| [RunProcedureInput](/concepts/runprocedureinput) | value | none | a named procedure to follow, with its inputs |
| [StatusInput](/concepts/statusinput) | value | none | watch, answer or stop a task |
| [MyWork](/concepts/mywork) | view | none | every run the caller started that is still running |
| [DelegateInput](/concepts/delegateinput) | value | none | something said to the agent |
| [DownloadInput](/concepts/downloadinput) | value | none | a file or a document to download into the workspace |
| [FileTransfer](/concepts/filetransfer) | view | none | progress by bytes moved of bytes in all, then the path or the pointer |
| [UploadInput](/concepts/uploadinput) | value | none | a file in the workspace to upload |
| [FileList](/concepts/filelist) | view | none | the files with their sizes, kinds and when they were written |
| [FileEntry](/concepts/fileentry) | value | none | one file of the workspace |
| [Workspace](/concepts/workspace) | view | none | the workspace folder, and every act the app made in it on the ledger |
| [LocalProcedureInput](/concepts/localprocedureinput) | value | none | a procedure the app runs itself, with its steps in the app's own journal |
| [CatalogueInput](/concepts/catalogueinput) | value | none | a tenant or a brand, and a filter by source, kind of intelligence or vertical |
| [SourceCatalogueEntry](/concepts/sourcecatalogueentry) | view | none | one source in the catalogue with its connectors, kinds of reading and action, identity needed, rights tier, cost, state, coverage by cell and health |
| [ProbeIdentityInput](/concepts/probeidentityinput) | value | none | a held identity to probe |
| [HoldIdentityInput](/concepts/holdidentityinput) | value | none | a signed-in identity to hold for the tenant: the platform's own browser opens on the platform, the person signs in, and the session state is checkpointed once the probe reads signed in |
| [ReadSourceInput](/concepts/readsourceinput) | value | none | run one kind of reading of an installed connector from a cursor |
| [ReadSourcePage](/concepts/readsourcepage) | view | none | one page of source objects, the next cursor and the cells credited |
| [ActThroughConnectorInput](/concepts/actthroughconnectorinput) | value | none | run one kind of action with its arguments and their sources |
| [UndoActionInput](/concepts/undoactioninput) | value | none | the move to undo |
| [SyncRuleInput](/concepts/syncruleinput) | value | none | a sync rule to write, preview or arm |
| [SyncPreview](/concepts/syncpreview) | view | none | what a sync rule would read and push, before it is armed |
| [CaptureInput](/concepts/captureinput) | value | none | a page the person opened, handed over by the capture extension |
| [CoverageByCellInput](/concepts/coveragebycellinput) | value | none | a source, or a scope with a window |
| [BackfillInput](/concepts/backfillinput) | value | none | a source, an access method, a window and a plane; the platform fills the reading, so the same request over a catalogue read again is new work |
| [LineageInput](/concepts/lineageinput) | value | none | an artefact or an acquisition unit |
| [Lineage](/concepts/lineage) | view | none | every hop of a unit with its stamp and span, and its downstream footprint, marking unavailable what a store cannot answer |
| [BrowseOpenInput](/concepts/browseopeninput) | value | none | open a browsing session under the caller's grant, with a held identity, a proxy policy and a filter |
| [BrowseStepInput](/concepts/browsestepinput) | value | none | one step in an open browsing session |
| [BrowseTakeOverInput](/concepts/browsetakeoverinput) | value | none | a person takes the wheel of a session, or hands it back |
| [BrowseViewInput](/concepts/browseviewinput) | value | none | a browsing session whose live view is read |
| [DownloadSetInput](/concepts/downloadsetinput) | value | none | one or many addresses to download through the download manager, from a page or from anywhere |
| [DownloadControlInput](/concepts/downloadcontrolinput) | value | none | pause, resume or cancel one download or a set |
| [WatchSiteInput](/concepts/watchsiteinput) | value | none | a site watch to write, preview or arm |
| [PageChangesInput](/concepts/pagechangesinput) | value | none | page changes for a site or a watch in a window |
| [TemplateInput](/concepts/templateinput) | value | none | an extraction template to write, preview, arm or retire |
| [ProposeTemplateInput](/concepts/proposetemplateinput) | value | none | a sample page the person marked, from which the model proposes a template's fields with evidence spans for the person to confirm |
| [SetAsideRunInput](/concepts/setasideruninput) | value | none | a queued run to keep and never take up, with a person's plain reason |
| [ScrapeRunsInput](/concepts/scraperunsinput) | value | none | the runs of a template in a window |
| [CaptureRuleInput](/concepts/captureruleinput) | value | none | a person's capture rule to write: the platform, the mode, the way, the default scope, the never list and the person's redactions |
| [CaptureRulesInput](/concepts/capturerulesinput) | value | none | which capture rules to read: one platform, or all of the person's |
| [SignUpInput](/concepts/signupinput) | value | none | the company a person names on their first sign-in, so the platform makes their tenant on the trial plan |
| [InviteInput](/concepts/inviteinput) | value | none | an address and a role to invite to the tenant, with where the role is held |
| [ErasePersonInput](/concepts/erasepersoninput) | value | none | the person to erase, and the second administrator's verification |
| [ReceiptsInput](/concepts/receiptsinput) | value | none | which receipts to read |
| [Receipts](/concepts/receipts) | view | none | the receipts of exports and erasures |
| [NotificationChannelInput](/concepts/notificationchannelinput) | value | none | a channel to write: its kind, its address and the notices it carries |
| [NotificationRuleInput](/concepts/notificationruleinput) | value | none | a rule to write: the notices, the channel, quiet hours and the digest |
| [BoardInput](/concepts/boardinput) | value | none | a board to write, with its tiles |
| [BoardReadInput](/concepts/boardreadinput) | value | none | a board to read, over a period |
| [BoardAnswer](/concepts/boardanswer) | view | none | a board with every tile's numbers, each with its basis and its population |
| [UsageStatementInput](/concepts/usagestatementinput) | value | none | the period of a usage statement |
| [InvoicesInput](/concepts/invoicesinput) | value | none | the period of the invoices to read, or all |
| [ChangePlanInput](/concepts/changeplaninput) | value | none | the plan kind to change to |
| [PlanChange](/concepts/planchange) | view | none | a plan change as a proposal, with the provider's own page for payment |
| [MethodsInput](/concepts/methodsinput) | value | none | a question to find methods for, or nothing for every method |
| [IntelligenceInput](/concepts/intelligenceinput) | value | none | a subject and a kind of intelligence to read |
| [IntelligenceAnswer](/concepts/intelligenceanswer) | view | none | a kind of intelligence about a subject: the facts with their basis, the coverage and the date |
| [SeedInput](/concepts/seedinput) | value | none | the manifest to seed from, and the window in months |
| [SourceProcedureInput](/concepts/sourceprocedureinput) | value | none | the source whose procedure to read |
| [KeepBasketInput](/concepts/keepbasketinput) | value | none | a basket to keep |
| [BasketReadInput](/concepts/basketreadinput) | value | none | a basket and what to read it over: one subject, a set, a scope or a cut into groups, with the window |
| [ValueChainInput](/concepts/valuechaininput) | value | none | the vertical, and the brand whose participants are placed |
| [SystemsModelsInput](/concepts/systemsmodelsinput) | value | none | the vertical or the kind of offering the templates must fit; both absent asks for every template |
| [MarketSimulationInput](/concepts/marketsimulationinput) | value | none | the template, the market, the interventions that stand for a strategy, and the run's bounds |
| [SimulationFrameInput](/concepts/simulationframeinput) | value | none | the simulation whose frame is read |
| [FitSearchInput](/concepts/fitsearchinput) | value | none | the brand, the end the search starts from, its offerings or its concept, and the verticals to consider |
| [FitFrameInput](/concepts/fitframeinput) | value | none | the search whose frame is read |
| [FitPlaysInput](/concepts/fitplaysinput) | value | none | the phase of the search, and the vertical or kind of offering the tactics must fit |
| [FitReadingInput](/concepts/fitreadinginput) | value | none | one result of a person's own fit test, as they state it |
| [PlaceParticipantInput](/concepts/placeparticipantinput) | value | none | a party placed in a role on a stock of a vertical's chain |
| [MarketTwinInput](/concepts/markettwininput) | value | none | the twin to read, as of a date |
| [MakeMarketTwinInput](/concepts/makemarkettwininput) | value | none | the market and the template to instance a twin from |
| [LayStrategyInput](/concepts/laystrategyinput) | value | none | a strategy laid over a twin: its armed plays become the interventions of one simulation |
| [ModelFamiliesInput](/concepts/modelfamiliesinput) | value | none | the vertical or the representation the families must fit; both absent asks for every family |



## leads


| object | kind | scope | description |
|---|---|---|---|
| [Candidate](/concepts/candidate) | work | brand | an entity gathering signals toward the qualifying rung of one kind of buyer |
| [Lead](/concepts/lead) | work | brand | a candidate that reached the qualifying rung, delivered under the plan's limit or withheld |
| [WithheldReason](/concepts/withheldreason) | value | none | why a lead is withheld: the limit reached, with the count reproducible from the record |
| [WithheldCount](/concepts/withheldcount) | view | brand | the leads that exist and the plan does not yet deliver, by kind of buyer and temperature; never who |
| [LeadCondition](/concepts/leadcondition) | row | platform | something a person can mark on a lead; platform rows, and a tenant's own |
| [Outcome](/concepts/outcome) | fact | brand | a condition as marked, by whom and when; measured and never guessed |
| [RoutingRule](/concepts/routingrule) | definition | brand | a predicate over leads with a person or a team attached; its dry run is the preview |
| [Capacity](/concepts/capacity) | property | user | how many new leads a user can take in a period, how many they hold, and when it refills |
| [LeadAssignment](/concepts/leadassignment) | fact | brand | which user a lead went to, under which rule, who else was eligible, and the odds |
| [Package](/concepts/package) | view | brand | the lead as handed to a person: why it is a lead, who this buyer is, which offerings fit, the moves to choose from |
| [OfferingFit](/concepts/offeringfit) | value | none | an offering that fits a lead, and why |
| [SpeedToLead](/concepts/speedtolead) | definition | platform | the delay from delivery to the first touch, read from two flows |
| [NotificationChannel](/concepts/notificationchannel) | row | tenant | where a notice goes: in the app, by email, in Slack, by webhook or in the browser extension, verified by a test notice before it carries one |
| [NotificationRule](/concepts/notificationrule) | definition | tenant | which notices go to which channel for whom, with quiet hours and a digest cadence; never what happens, only who is told |



## gateway


| object | kind | scope | description |
|---|---|---|---|
| [Operation](/concepts/operation) | row | platform | one tool as the API serves it: a route, its input and output as owning types, its errors, its limits; generated |
| [Verb](/concepts/verb) | row | platform | one of the words that order the public surface; a verb with no operation yet is shown as not yet served |
| [Answer](/concepts/answer) | value | none | what every operation gives: the value, its population, and for every count which of the three positions it is in |
| [Telling](/concepts/telling) | definition | tenant | an address a tenant registered to be told at, with its signed calls as durable work |
| [FailedCall](/concepts/failedcall) | fact | tenant | a signed call that did not land, with why, and a way to send it again |
| [ServerDescription](/concepts/serverdescription) | value | none | what the MCP server publishes: where the provider is, the proof method, the smallest scopes that work |



## ops_console


| object | kind | scope | description |
|---|---|---|---|
| [Stock](/concepts/stock) | view | platform | for one kind, one place and one scope: the level, the rates, the age of the oldest with its reason, the count past the longest wait, and who reads it |
| [Oldest](/concepts/oldest) | value | none | the oldest unit in a place, with its reason |
| [Journey](/concepts/journey) | view | none | every hop of one unit, walked from its id alone, with a bound on depth |
| [WaitingItem](/concepts/waitingitem) | view | none | a unit in a place whose reader is a person |
| [Pairing](/concepts/pairing) | row | platform | two kinds the product needs together, the rule that joins them, and the sentence shown when one is missing |
| [Capability](/concepts/capability) | row | platform | a capability the product depends on: where it is on, when it was last proved, and what depends on it |
| [PlatformState](/concepts/platformstate) | view | platform | every service with its life, every reader's distance behind the log, events set aside, settings changed, cost by kind |
| [BuildState](/concepts/buildstate) | view | platform | every build stage, its acceptance procedure, and when it last showed red and then green |
| [StageState](/concepts/stagestate) | value | none | one stage of the build as the view shows it |
| [SavedQuestion](/concepts/savedquestion) | definition | follows | a question over the view a person or the agent keeps |
| [Board](/concepts/board) | definition | tenant | a board of tiles for an audience, at tenant or platform scope, drawn from saved questions |
| [Tile](/concepts/tile) | value | none | one tile of a board: a saved question, a chart kind, a period and the comparison with the period before |



## market


| object | kind | scope | description |
|---|---|---|---|
| [Company](/concepts/company) | entity | shared | a company, an entity of the record |
| [Brand](/concepts/brand) | entity | shared | a brand, shared; a tenant's own and a rival are one kind, and the marking is a fact |
| [Offering](/concepts/offering) | entity | shared | what a brand sells, with its structure and its prices as facts |
| [OfferingStructure](/concepts/offeringstructure) | value | none | package, variant, part or complement |
| [KindOfBuyer](/concepts/kindofbuyer) | definition | brand | a kind of customer a brand sells to, written as a predicate so its members can be counted; it compiles or it is not ready |
| [Binding](/concepts/binding) | value | none | a buyer profile bound to an offering or a segment |
| [AudienceMapCell](/concepts/audiencemapcell) | view | brand | the shared subjects, the share, the lift, the window and the negative control, with the size as bounds |
| [CommunityPosture](/concepts/communityposture) | fact | shared | open, conditional, closed or unknown, from the removal rates in the room |
| [Segment](/concepts/segment) | definition | brand | a buyer profile narrowed by a place, a size or a channel |
| [Market](/concepts/market) | definition | brand | a buyer profile in a place, sized in three positions, with the four stages |
| [MarketStage](/concepts/marketstage) | value | none | one of the four stages of a market |
| [Chain](/concepts/chain) | definition | platform | the parties around a sale, each handing demand to the next; its stocks with a side and a reader, its handovers counted as facts, its leaks |
| [ChainStock](/concepts/chainstock) | value | none | one stock of a chain, with its side, its unit, its reader and a count with its basis |
| [ChainHandover](/concepts/chainhandover) | value | none | a flow between two stocks, with its count as a fact |
| [Leak](/concepts/leak) | value | none | a resting place with no reader |
| [Voice](/concepts/voice) | definition | brand | a platform account or person that speaks for the brand, with its role and its code |
| [RivalMarking](/concepts/rivalmarking) | fact | brand | a tenant's marking of a rival, with the evidence that made it one; never on the shared plane |
| [Map](/concepts/map) | view | brand | the brand's graph, every rival in the same shape, the markets, the channels, the chain, the voices, and for each part its coverage; it holds no rows of its own |
| [BrandDesignSystem](/concepts/branddesignsystem) | definition | brand | the brand's visual system made from its pages held whole: every value with its basis and the artefacts it was read from, and the same values in the platform's token shape |
| [BrandGradient](/concepts/brandgradient) | value | none | one gradient a site declares, with the colours read out of it |
| [BrandDuration](/concepts/brandduration) | value | none | one duration of motion a site declares |
| [BrandEasing](/concepts/brandeasing) | value | none | one timing function a site declares |
| [BrandKeyframes](/concepts/brandkeyframes) | value | none | one keyframes block a site declares: an animation of its own |
| [BrandComponent](/concepts/brandcomponent) | value | none | one recurring part of the pages: a class the stylesheet styles as a surface and the pages use |
| [BrandAsset](/concepts/brandasset) | value | none | one file a page loads, held whole in bronze |
| [BrandRatio](/concepts/brandratio) | value | none | the ratio of a modular type scale, with the name the field gives it |
| [BrandHierarchyLevel](/concepts/brandhierarchylevel) | value | none | one level of the visual hierarchy and what makes it up |
| [BrandRhythm](/concepts/brandrhythm) | value | none | the vertical rhythm of the pages |
| [BrandBorder](/concepts/brandborder) | value | none | one border width and style declared |
| [BrandBreakpoint](/concepts/brandbreakpoint) | value | none | one width a media query turns on |
| [BrandLayer](/concepts/brandlayer) | value | none | one stacking layer: a z-index declared and what sits on it |
| [BrandGrid](/concepts/brandgrid) | value | none | the layout grid of the pages |
| [BrandIconography](/concepts/brandiconography) | value | none | the icon system the pages use |
| [BrandElement](/concepts/brandelement) | value | none | one element of the brand by kind, the old layer's element kinds kept |
| [BrandTrait](/concepts/brandtrait) | value | none | one motif of the brand, read from the measured values by a named rule |
| [BrandExports](/concepts/brandexports) | value | none | the design system in the shapes the tools outside the platform read, each generated from the typed values |
| [BrandCoordinate](/concepts/brandcoordinate) | value | none | one option of every design axis: where a variant sits |
| [BrandDelta](/concepts/branddelta) | value | none | one value a variant changes over its parent, by its path |
| [BrandVariant](/concepts/brandvariant) | value | none | the system at one coordinate: a sparse delta over its parent, made by one derivation; the old layer's variants, axes and derivations kept and made rows |
| [BrandFrame](/concepts/brandframe) | value | none | one frame of a template: its role, its layout, the scaffold a build reads, the values and elements it uses |
| [BrandTemplate](/concepts/brandtemplate) | value | none | a template of one format on one variant: the frames, their CSS from the resolved values, the motifs and elements it carries; derived by rule, and versioned with the system |
| [BrandDecision](/concepts/branddecision) | fact | brand | a tenant's decision on one value of the brand's design system: accepted, declined, or changed to the tenant's own; the brand's memory, read by the merge and by every builder |
| [BrandChange](/concepts/brandchange) | value | none | one value that differs between two versions of a design system |
| [BrandDesignSystemDiff](/concepts/branddesignsystemdiff) | view | brand | what changed between two versions of a brand's design system |
| [BrandColour](/concepts/brandcolour) | value | none | one colour of a brand's site, as one hex value, with where it was read and how well founded it is |
| [BrandFace](/concepts/brandface) | value | none | one type face of a brand's site by its role |
| [BrandTypeStep](/concepts/brandtypestep) | value | none | one size of a brand's type scale |
| [BrandStep](/concepts/brandstep) | value | none | one step of spacing or one radius |
| [BrandShadow](/concepts/brandshadow) | value | none | one shadow value |
| [BrandLogo](/concepts/brandlogo) | value | none | the brand's logo: its address on the site and its file when the file is held |
| [BrandSiteToken](/concepts/brandsitetoken) | value | none | one custom property a site declares on its root |
| [MapPart](/concepts/mappart) | value | none | one part of the map: measured, under test or never read, and never two |
| [Vertical](/concepts/vertical) | definition | platform | one market worked as a whole: its chain, its roles, its segments, its words and rules; ready or visibly not ready |
| [Word](/concepts/word) | value | none | one of the market's own words, with its meaning |
| [SegmentOfAVertical](/concepts/segmentofavertical) | definition | platform | the slice of a vertical a brand sells to, with its template |
| [RoleAroundADecision](/concepts/rolearoundadecision) | row | platform | one register of the roles people and organisations play around a decision and a market; a role never makes a buyer |
| [Template](/concepts/template) | definition | platform | a segment's vertical pack: rows a brand installs as copies naming their origin; its own origin is the vertical's pack; it carries a planted defect |
| [ChannelRule](/concepts/channelrule) | value | none | a channel with its rule |
| [InstalledTemplate](/concepts/installedtemplate) | value | none | which template a brand installed, at which version, and how many copies |
| [WayOfGoingToMarket](/concepts/wayofgoingtomarket) | row | platform | how a brand gets buyers, held as rows and never as code |
| [Community](/concepts/community) | entity | shared | a room where people gather |
| [Application](/concepts/application) | row | platform | one customer question the platform can answer over a vertical, with what it needs, what it gives, and the check that would show it wrong |
| [SeedManifest](/concepts/seedmanifest) | definition | platform | what the seed of a tenant reads and what each file becomes: the files with their hashes, the corpus and the window, the mapping of each file to the objects it makes |
| [SeedReceipt](/concepts/seedreceipt) | fact | platform | what a seed wrote: the manifest's version, the window, the counts by kind, what was not ready with its reasons, and the hashes |
| [KindOfMotive](/concepts/kindofmotive) | row | platform | a registered kind of motive a buyer or a router carries: what they want, what puts them off, the pain, the trigger, the job to be done, the proof they accept, the number they judge success by, the first need, and what makes them commit or stay |
| [Motive](/concepts/motive) | value | none | one motive of a buyer profile or a router: its kind, its text and its evidence |
| [LeadsTo](/concepts/leadsto) | value | none | one buyer profile leading to another: brought in, becoming, or crossing to, with the rate |
| [EconomicReading](/concepts/economicreading) | value | none | a number about a buyer profile that is not a count of members, in exactly one of three positions: a summary measured, an estimate with its interval, or a parameter stipulated |
| [RouteToBuyer](/concepts/routetobuyer) | value | none | a route to a buyer that is not a community: a voice, a router, a source or a paid surface, with how much of the kind it reaches now |
| [ReferabilityCondition](/concepts/referabilitycondition) | row | platform | one of the ten conditions that must hold before a professional puts a name behind a brand; every vertical pack writes its own instance with its own check |
| [ReferabilityStatus](/concepts/referabilitystatus) | value | none | one referability condition for one brand, with its status and its evidence |
| [MarketSizing](/concepts/marketsizing) | value | none | one sizing position of a market, with the count and the definition the reading used |
| [NumberInPosition](/concepts/numberinposition) | value | none | one number in exactly one of three positions: a summary measured, an estimate with its interval, or a parameter stipulated |
| [SizingPosition](/concepts/sizingposition) | row | platform | a position a market is sized in, a register a person extends by a row: total, serviceable, signalling, customers, reachable, winnable, each with its definition |
| [PermissionHeld](/concepts/permissionheld) | fact | follows | a registration, a licence, an approval or a certification one party holds in one country in one role, as a regulator's register records it |
| [Gazetteer](/concepts/gazetteer) | row | platform | the register of places: a place's names and their forms, its parent in the hierarchy a count rolls up through, its coordinates and its cell, its population and its source |
| [ComparisonQuestion](/concepts/comparisonquestion) | row | platform | one of the closed list of comparisons |
| [DriverNode](/concepts/drivernode) | value | none | one node of a value driver tree: a leaf that a party states, or a formula over its children |
| [Assumption](/concepts/assumption) | value | none | one assumption a business model discloses, and the driver it rests on |
| [CalculationShape](/concepts/calculationshape) | row | platform | one of the few ways a buyer profile earns value from an offering, as a driver tree over role names that a business model binds to its own drivers: a sales pipeline to a recurring contract; a client won then a retainer over its tenure; a proposal won then a project; a deal then margin on goods; a player or member won then lifetime value less acquisition cost; staff hours saved (the research of 27 September, section 3.1) |
| [BusinessModel](/concepts/businessmodel) | definition | platform | how one buyer profile earns, and the driver tree that turns that into the return one offering gives it; ready only when the tree reaches its four outputs and every dimension follows |
| [BenchmarkPopulation](/concepts/benchmarkpopulation) | value | none | who a benchmark measured, as the source states it |
| [Benchmark](/concepts/benchmark) | fact | shared | a published or platform-derived number for a value driver over a stated population and period, with its interval and the rights its source allows; never read by an estimate without all four |
| [StatedNumber](/concepts/statednumber) | fact | brand | one number a buyer stated about itself, within its driver's bounds, under the consent ground the surface stated; never edited, a later statement is a later fact |
| [FrameInput](/concepts/frameinput) | value | none | one input a frame read, with where it came from and its basis |
| [Sensitivity](/concepts/sensitivity) | value | none | the change in the return for a one-step change of one stated driver |
| [SimulationRun](/concepts/simulationrun) | work | platform | the one evaluator run over sampled inputs to give a frame its intervals; deterministic under its seed; stops at its budget with the interval it reached |
| [Allowance](/concepts/allowance) | value | none | one kind of usage a tier includes, with the quantity |
| [PriceTier](/concepts/pricetier) | value | none | one tier of the tenant's price ladder: its prices, its allowances, its offerings, who it is for, and where on the rivals' distribution it was set |
| [PriceLadder](/concepts/priceladder) | row | platform | the tenant's tiers in order with the study that set them; extends the price list, whose version in force the metering reads; a change is a new version |
| [MarginCheck](/concepts/margincheck) | value | none | the ladder's gross margin against the metered cost of a lead and of a call, in one of three positions; never a typed cost |
| [PricingStudy](/concepts/pricingstudy) | fact | platform | one run of the pricing methods over the frames of every buyer profile and the rivals' price claims of a window, with its candidates as a set of options, the decision and its reasons, and the margin check |
| [ReadingOffered](/concepts/readingoffered) | definition | brand | the estimator offered to a buyer profile in return for a contact: the model it evaluates, the drivers it asks in order, what is shown at once and after the contact, the consent it states, its page, its play and the rung a submission lands on |
| [ModelsInput](/concepts/modelsinput) | value | none | the vertical, the segment or the buyer profile whose business models are asked for; all three absent asks for every model |
| [BenchmarksInput](/concepts/benchmarksinput) | value | none | the driver, and the buyer profile or population the benchmarks must apply to |
| [LadderInput](/concepts/ladderinput) | value | none | the ladder in force, or one version |
| [EstimateReturnInput](/concepts/estimatereturninput) | value | none | the buyer, the offering or tier, the numbers stated for this ask, and whether to simulate |
| [PricingStudyInput](/concepts/pricingstudyinput) | value | none | the methods to run, the buyer profiles, and the window of the rivals' claims |
| [ReadingOfferedInput](/concepts/readingofferedinput) | value | none | the buyer profile, the model and the drivers to ask |
| [KindOfOffering](/concepts/kindofoffering) | row | platform | one of the shapes an offering is sold in, so a tactic and a systems model can say which kinds they apply to |
| [BuyingBehaviour](/concepts/buyingbehaviour) | value | none | how one participant buys, as observable stocks and flows: the stage it stands on, how often it buys, what starts a purchase, what constrains it, and the readings that say so |
| [ParticipantImpact](/concepts/participantimpact) | value | none | the nature of one participant's impact on another role of the chain |
| [MarketParticipant](/concepts/marketparticipant) | definition | brand | one party of a market in one role on one stock of a vertical's chain, with its buying behaviour and its impact on the other roles; placed by a person, by the placement method of the library, or by a template |
| [ModelStock](/concepts/modelstock) | value | none | one stock of a systems model: the units of one kind in one place, read from a chain stock where the chain holds one |
| [ModelFlow](/concepts/modelflow) | value | none | one flow of a systems model between two stocks, its rate a driver tree the one evaluator computes each step |
| [FeedbackLoop](/concepts/feedbackloop) | value | none | one loop of a systems model: balancing or reinforcing, the stocks it runs through, its delay and its limit |
| [Intervention](/concepts/intervention) | value | none | what a play does to a systems model: a change to one flow's rate, delay, inflow, outflow or limit, from a stated step of the horizon |
| [SystemsModelTemplate](/concepts/systemsmodeltemplate) | row | platform | one systems model of a market, written as rows over the calculation shapes and the predicates: its stocks, its flows, its loops, its delays and its parameters, for a family of verticals and kinds of offering; versioned; carries a planted defect so its check can go red |
| [StockTrajectory](/concepts/stocktrajectory) | value | none | one stock's level at every step of a simulation, each an interval at the stated level |
| [LoopGain](/concepts/loopgain) | value | none | the gain a simulation read for one loop |
| [MarketSimulation](/concepts/marketsimulation) | work | brand | one run of a systems model template over the record's readings with a strategy laid over it as interventions; the one evaluator steps every flow; deterministic under its seed; stops at its budget with the trajectories it reached |
| [MarketSimulationFrame](/concepts/marketsimulationframe) | fact | brand | what a market simulation gave: the trajectory of every stock, the gain of every loop, the sensitivity to every intervention, and the set of options that compares the strategies laid over the same template |
| [FitReading](/concepts/fitreading) | fact | brand | one result of a person's own product-market-fit test, as a reading the record keeps beside its readings: the tactic run, the market it was run in, the measure and its value in one of three positions, the sample, where it came from, and the hypothesis it settles |
| [FitCandidateMarket](/concepts/fitcandidatemarket) | value | none | one market the search scored: its unmet demand and its supply from the template's run, its rivals, the plays that would be alpha there and the ones that are table stakes, and its score with the reasons |
| [SculptedOffering](/concepts/sculptedoffering) | value | none | the offering as the search shaped it for one buyer profile: the value drivers it moves, the price position, the positioning against the rivals' claims, and the frame of a sale that priced it |
| [FitStep](/concepts/fitstep) | value | none | one step of the search, a hypothesis settled by readings |
| [FitVerdict](/concepts/fitverdict) | value | none | the search's verdict for one market: fit, no fit or not yet read, with the readings behind it |
| [FitSearch](/concepts/fitsearch) | work | brand | the search for product-market fit from either end: an offering looking for its most advantageous markets, or a concept looking for whether a market exists and how to sculpt the offering to unmet demand; each step a hypothesis settled by readings |
| [FitSearchFrame](/concepts/fitsearchframe) | fact | brand | what a fit search gave: the markets ranked, the offering sculpted per buyer profile, the tactics proposed to test the fit, the verdict per market, and the set of options that compares the markets |
| [ValueChain](/concepts/valuechain) | view | brand | the chain of a vertical with the participants placed on its stocks, the loops the template names over it, and when it was read; answered from the chain, the participants and the readings and held nowhere |
| [ModelFamily](/concepts/modelfamily) | row | platform | one family of quantitative model a market may be expressed in over the substrate: what it represents, the quantities it holds, what it reads from the record, what it gives, the solver that steps or solves it, and the check that proves it; a template names its family and a vertical chooses among them |
| [GameMove](/concepts/gamemove) | value | none | one role's choice in a game of roles: the options it may choose among, its payoff as a driver tree over the frame's drivers, and its best response as the solver reports it |
| [GameOfRoles](/concepts/gameofroles) | value | none | a game-theoretic model laid over a template: the roles as players, each with its options and its payoff as a driver tree, and the equilibrium the solver reports; every payoff is computed by the one evaluator over the frame's drivers |
| [StockLevel](/concepts/stocklevel) | value | none | one stock's level at one moment, in one of three positions |
| [MarketTwin](/concepts/markettwin) | definition | brand | A digital twin is a model of a market that stays current because the record feeds it. It holds no second copy of the readings. For one brand, that model is one template of a model family laid over the record's readings. The template brings the vertical's value chain and the parties placed on it. As of a date, the twin carries the level of every stock. It also carries the simulations that ran on it, in order. The plays the brand's strategy has armed arrive as its interventions |
| [MarketTwinState](/concepts/markettwinstate) | fact | brand | the state of a twin at one step of one simulation: the level of every stock, so the twin's trajectory is facts in gold and never a rebuild |



## interfaces


| object | kind | scope | description |
|---|---|---|---|
| [DesignAxis](/concepts/designaxis) | row | platform | one axis a design system varies along, with its options; a coordinate names one option of every axis; a new axis is a row |
| [Shell](/concepts/shell) | row | platform | the shell, drawn once: its slots, its parts, its three widths |
| [Surface](/concepts/surface) | row | platform | one node of the architecture: its route, the object it shows, its owner, its class, who sees it, its nine states |
| [Rendering](/concepts/rendering) | work | platform | a proof that a surface renders inside the real shell, arrived at from a sibling |
| [DesignSystem](/concepts/designsystem) | row | platform | the tokens, the two type systems, the three tonal levels, the closed glyph set, the motion rules, the component library |
| [RouteDeclaration](/concepts/routedeclaration) | definition | platform | one route of the register with the data it loads: the tools it calls, their inputs and the slot each answer fills, and its transition class |
| [RouteLoad](/concepts/routeload) | value | none | one tool a route calls when it opens: the tool, its inputs from the route's params, and the slot its response card fills |
| [ConnectionState](/concepts/connectionstate) | value | none | the one WebSocket a session keeps to the platform, as the status bar shows it |
| [AccessibilityAudit](/concepts/accessibilityaudit) | fact | platform | the audit of one rendering against the bar: the rules run, the violations by rule with the element, the state |



## strategy


| object | kind | scope | description |
|---|---|---|---|
| [Strategy](/concepts/strategy) | definition | strategy | a strategy under a brand, or under several that share an owning company |
| [Goal](/concepts/goal) | definition | strategy | a measure, a target, a window, and the version of the measure it was set against |
| [Play](/concepts/play) | definition | follows | written once, filled per brand: its goal, condition, class, tactic, the move it proposes, its price, its measure, its forecast rule, its comparison, when it stops |
| [Router](/concepts/router) | definition | platform | a person or a voice whose worth is who they send, with its own ladder and its value unit |
| [Tactic](/concepts/tactic) | row | platform | the named, reusable method that a move applies; what works is learned tactic by tactic; the catalogue of the standard mechanisms people use to find product-market fit is rows of this register, each with the phase of the search it serves |
| [Move](/concepts/move) | work | strategy | one proposed carrying out of a play: its forecast, its actions, its assignments, its effect |
| [MovesPass](/concepts/movespass) | work | platform | one pass of the beat that proposes the ready moves: every open instance of an armed play read, the vertices whose edges hold proposed under the instance's trigger, and the vertices held counted |
| [Action](/concepts/action) | work | strategy | one action of a move, run only through the permission check, with its inverse captured first |
| [ActionArgument](/concepts/actionargument) | value | none | an argument and where its value came from |
| [Forecast](/concepts/forecast) | fact | strategy | written before the first action: the number expected and the number that proves it wrong, each with an interval |
| [Effect](/concepts/effect) | fact | strategy | the change where it ran against the change where it did not, with an interval; or withheld with what would settle it |
| [Impact](/concepts/impact) | fact | strategy | a kind of signal: the effect, the play, the tactic, the brand; it changes what happens next |
| [Budget](/concepts/budget) | parameter | strategy | a strategy's budget by kind, of the receive family; reading the public market is never in it |
| [GraphEdge](/concepts/graphedge) | value | none | one edge of the graph a strategy, a play or a move is: from a done vertex to the next, guarded by a predicate over the record, or by the row always |
| [DesignOfAnEffect](/concepts/designofaneffect) | row | platform | one design that reads an effect against the tide: what it needs, what it assumes, when it is used, and what makes its answer cannot tell; the five the model places on the graph, each a row |
| [PlayClass](/concepts/playclass) | row | platform | one class a play reads against the rivals and the tide: table stakes, benchmark, beta, alpha, expansion or hedge; a class is a hypothesis read on the beat, never typed |
| [KindOfMove](/concepts/kindofmove) | row | platform | one kind of move a play proposes: what it does, how far its actions reach, how it is read, the class it usually reads, the play families it serves, whether it routes an actor and carries content |
| [Game](/concepts/game) | row | platform | the game a strategy plays in its market, by value chain: the way of going to market, the twin's template, the roles that play, the play families that read alpha there, what is counted, and the dynamics it assumes |
| [Policy](/concepts/policy) | row | platform | a rule that chooses among the ready arms of a strategy, a play, an actor or a content, and logs the odds of its choice; a tenant may choose another row and replay it on the history first |
| [Actor](/concepts/actor) | view | none | a player of the strategy's game: one view over a user with a role held, a voice that speaks for the brand, or a held identity, with its accounts, the kinds of action it may take, its grant, its standing and its capacity |
| [PropensityToMove](/concepts/propensitytomove) | fact | strategy | the chance that a lead moves up a rung within the window if this actor touches it or this content reaches it, with its interval and its basis; a hypothesis of the face propensity; distinct from a buyer's Propensity to buy an offering (14 §2.4), which is the lead's side of the same question |
| [ClassReading](/concepts/classreading) | fact | strategy | a play's class read on a beat from the rivals' coverage, the effect against the tide and the twin's sensitivity; moved when the reading moves, with its event |
| [KindOfPlayObserved](/concepts/kindofplayobserved) | fact | brand | a brand observed running a kind of play, with the evidence that showed it: the rivals' coverage of a kind of play is the count of rival brands with a standing observation of it; written by the brand graph's build from a domain (WORK-AHEAD row ) or by a person who marks it |
| [ClassPass](/concepts/classpass) | work | platform | one pass of the beat that reads the class of every armed play from the rivals' coverage of its kind against the parameter's count: a reading written for each, the class moved where the reading moved, and the claim under test settled and made again |
| [ForecastScore](/concepts/forecastscore) | fact | strategy | a forecast scored against its effect by the proper rule fixed on the row, read as of what was knowable when the forecast was written |
| [KindOfFraming](/concepts/kindofframing) | row | platform | a way a sale is framed, a register a person extends by a row: mechanistic, emotional, motivational, social proof, risk and loss, time and urgency, status, curiosity, authority, belonging, reciprocity, scarcity, simplicity, craft, and more |
| [SaleFrame](/concepts/saleframe) | fact | brand | the sale framed for one buyer: what the first sale costs them, the value and the return in their own numbers with their basis, the payback, the sensitivity, and the framing chosen with its evidence; computed once by the one evaluator from a business model, and read by the sale, the estimator page and the signal |
| [KindOfPlay](/concepts/kindofplay) | row | platform | one kind of play a strategy may run in a market: its family, what it does, the mechanism it works by, what it changes on the living market's model (which flow, loop, stock or payoff, and how), the number that decides it with its control, its known failure, the phases of the search it serves, the ways of going to market and kinds of offering it fits, the roles it moves, the class it usually reads against the rivals, and the counter-play a rival makes; a play of the strategy engine names its kind, and the catalogue of tactics names the methods a kind runs |



## models


| object | kind | scope | description |
|---|---|---|---|
| [LayerOfLikeness](/concepts/layeroflikeness) | property | none | the share each of three layers contributed, held apart and never blended |
| [Model](/concepts/model) | row | platform | a model: the task it decides, its kind, its address, its calibration, its state |
| [KnownExamples](/concepts/knownexamples) | fact | platform | labelled pairs or items in both directions, kept apart from the audit's samples |
| [ModelStatistics](/concepts/modelstatistics) | fact | platform | base rates, calibration by segment and version, interval coverage, and familiarity |
| [Estimate](/concepts/estimate) | fact | follows | a point with its interval, the balance of evidence, and how familiar the case is; or withheld |
| [IntelligenceLayer](/concepts/intelligencelayer) | row | platform | one of the 28 kinds, with its mechanism, what goes in and out, what it assumes, how it fails, and the reading that would show it wrong |
| [DerivedGraph](/concepts/derivedgraph) | definition | follows | weighted connections computed from the record's connections by a named recipe over a window; rebuilt, never edited |
| [PolicyDecision](/concepts/policydecision) | fact | follows | the choice made, the chance it had, the alternatives, the version of the policy, the outcome when read |
| [ModelCall](/concepts/modelcall) | fact | follows | one call of a model, metered against the unit it served |
| [ClusterCard](/concepts/clustercard) | view | follows | a group of subjects with the share of each layer first, its lists, its trend, the proxies that placed it, and how it was cut |
| [Method](/concepts/method) | row | platform | one research method of the library: the question it settles, when it applies and when not, its inputs, the deciding number and its bar, the control, its steps, its validity threats with the answer to each, and what it leaves on the record |
| [InstructionSet](/concepts/instructionset) | row | platform | the agent's standing instructions for a kind of job, assembled from versioned rows at run time: the stance, the rules of evidence, the method by question, the reporting form, the stopping rule and the words |
| [ConceptWeight](/concepts/conceptweight) | value | none | one concept with its weight in an entity's content affinity, and the evidence that carries it |
| [ContentAffinity](/concepts/contentaffinity) | fact | follows | what an entity publishes, likes, stars, replies to and follows across every connector, as concept weights with their evidence over a window, kept and re-read on the beat |
| [Propensity](/concepts/propensity) | fact | follows | the propensity of one buyer to buy one offering: an estimate with its interval and its balance of evidence, and the causes as the evidence that moved it with their weights |
| [PropensitySheet](/concepts/propensitysheet) | view | none | one buyer's propensity across every offering at one time, with the offerings the profile does not bind as never measured |
| [BudgetForecast](/concepts/budgetforecast) | fact | follows | the spend a buyer can put to this kind of purchase in one period, month or quarter: an estimate with its interval and its balance of evidence, the inputs it read, and its calibration against what followed |



## studio


| object | kind | scope | description |
|---|---|---|---|
| [Draft](/concepts/draft) | work | follows | a thing being made in the definitions studio: the rows it is made from, its preview, its proofs |
| [Proof](/concepts/proof) | work | follows | one arm of the four run on a draft: what was planted and what the check read |



## documents


| object | kind | scope | description |
|---|---|---|---|
| [Document](/concepts/document) | definition | follows | a document built from the record: its kind, its recipe, its versions |
| [Recipe](/concepts/recipe) | value | none | what a document reads: saved views, predicates, estimates and figures |
| [Build](/concepts/build) | work | follows | one build of a document, every number naming the unit that supplied it |
| [ChippedNumber](/concepts/chippednumber) | value | none | a number in a document, with the unit that supplied it and its instrument |
| [Figure](/concepts/figure) | value | none | a figure of a recipe: what it shows, its form, the units it reads, the chip on every number |
| [Publishing](/concepts/publishing) | work | follows | a document put at an address, a kind of action with reach |
| [PublishingReceipt](/concepts/publishingreceipt) | value | none | the version, when, and the readings it carried |
| [WhatChanged](/concepts/whatchanged) | view | none | every number that moved, with its unit, and every figure replaced |
| [NumberChange](/concepts/numberchange) | value | none | one number that moved |
| [ReportSection](/concepts/reportsection) | value | none | one section of a report's recipe: its heading, the method it runs, the words of its audience and its figure |



## releases


| object | kind | scope | description |
|---|---|---|---|
| [Change](/concepts/change) | fact | platform | a merged commit on the main branch, with the part of the plan it moves and the checks that completed at it |
| [ReleaseArtefact](/concepts/releaseartefact) | fact | platform | one image for each repository, with its version and its hash |
| [Release](/concepts/release) | work | platform | a versioned, tagged artefact reaching production, with its readings and its receipt |
| [Receipt](/concepts/receipt) | fact | platform | when each role restarted and published ready, the readings the procedure took, and who cut the tag |
| [SettingsDeclaration](/concepts/settingsdeclaration) | definition | platform | every setting of every role, with its dimension, its default and where it may be changed |
| [SettingRow](/concepts/settingrow) | value | none | one setting |
| [Migration](/concepts/migration) | definition | platform | a change to a schema, forward only, re-declaring the list of applied migrations |
| [Rollback](/concepts/rollback) | work | platform | the previous artefact put back, with the readings after |



## network


| object | kind | scope | description |
|---|---|---|---|
| [Listener](/concepts/listener) | definition | platform | one listening endpoint of one role: its port, protocol and exposure class |
| [Route](/concepts/route) | definition | platform | one ingress route: a host and path prefix forwarded to one listener, over TLS |
| [Certificate](/concepts/certificate) | definition | platform | a TLS certificate issued inside the cluster by cert-manager and kept as a secret |
| [PrivateNetwork](/concepts/privatenetwork) | definition | platform | the private network the machines share: its address range and the machines on it |
| [MachineAddress](/concepts/machineaddress) | value | none | one machine on the private network |
| [LoadBalancer](/concepts/loadbalancer) | definition | platform | the rented load balancer in front of the ingress: ports, health check, and how the client address is passed |
| [Ingress](/concepts/ingress) | definition | platform | the Gateway API implementation in front of the API gateway, one copy per machine sharing certificates through secrets |
| [ConnectionLimits](/concepts/connectionlimits) | parameter | platform | the bounds on one connection: request deadline, body size, idle timeout of a WebSocket, and connections per client address |
| [RateLimit](/concepts/ratelimit) | parameter | platform | requests allowed per window for one token, and per client address for the sign-in routes; over it the answer is 429 with Retry-After |
| [NetworkPolicy](/concepts/networkpolicy) | definition | platform | one allowed flow between two parties on the private network; everything not declared is denied |
| [ServiceNote](/concepts/servicenote) | value | none | the short-lived signed token the API gateway hands the role behind it: who is calling, for which service, until when |
| [ClientConnection](/concepts/clientconnection) | fact | tenant | one WebSocket the installed app keeps open to the platform: authenticated by the session's token in its first message, carrying progress, task events and file bytes |
| [LocalListener](/concepts/locallistener) | definition | user | one listener of the local server on a person's machine: the Unix domain socket or named pipe by default, and the TCP and WebSocket listeners when turned on, every one bound to the loopback address and never to a network interface; a caller proves itself with the install token in its first message |
| [EgressRelay](/concepts/egressrelay) | definition | platform | the outbound relay every connector's traffic leaves through, with bytes accounted per connector against a limit |
| [EgressReading](/concepts/egressreading) | fact | platform | bytes one connector sent and received through the relay on one day |



## observability


| object | kind | scope | description |
|---|---|---|---|
| [TelemetryContext](/concepts/telemetrycontext) | value | none | the W3C trace context every call, event and message carries: the trace id, the parent span, and the attributes the platform adds |
| [Span](/concepts/span) | fact | platform | one timed operation inside a trace, with its attributes and its outcome |
| [LogLine](/concepts/logline) | fact | platform | one structured log line: time, role, run, level, a message in plain words, and the trace it belongs to; secret values are redacted before export |
| [Metric](/concepts/metric) | definition | platform | one named measurement with its kind, its unit and the labels it may carry |
| [MetricReading](/concepts/metricreading) | fact | platform | one point of one metric |
| [Level](/concepts/level) | definition | platform | a service level: a metric, an aggregation over a window, a target, and the beat it is computed on; the ops console reads levels, never raw metrics |
| [LevelReading](/concepts/levelreading) | fact | platform | one computed value of one level |
| [Collector](/concepts/collector) | definition | platform | the one OpenTelemetry collector: its receivers, its processors, and its exporters |
| [SignalExport](/concepts/signalexport) | work | platform | one export of one signal kind from the collector to the store as Parquet |
| [SignalStore](/concepts/signalstore) | definition | platform | where signals land: object storage, one folder per signal kind and day, under a retention class per kind |
| [ConsolePanel](/concepts/consolepanel) | definition | platform | one panel of the ops console: the levels, stocks or alarms it draws, and the query it runs over the signal store |



## documentation


| object | kind | scope | description |
|---|---|---|---|
| [DocSection](/concepts/docsection) | definition | platform | one section of the documentation site: its purpose, its order and its pages |
| [DocPage](/concepts/docpage) | definition | platform | one page of the documentation site: where it comes from, its claims, its examples and its Markdown twin |
| [DocClaim](/concepts/docclaim) | value | none | one statement a page makes about the platform, typed live or target against the served contract |
| [DocExample](/concepts/docexample) | value | none | one example on a page, rendered in each language from one source and validated against its type |
| [DocIsland](/concepts/docisland) | definition | platform | one interactive island of the site: what it does, the SDK call it makes and whether it needs a key |
| [LlmsIndex](/concepts/llmsindex) | definition | platform | the index a model reads: every page with a one-line description, and the addresses of the full twin, the API document, the manifest and the Context7 configuration |
| [SiteBuild](/concepts/sitebuild) | work | platform | one build of the documentation site, with the checks it ran; nothing is published from a failed build |


---
title: "AccessibilityAudit"
description: "the audit of one rendering against the bar: the rules run, the violations by rule with the element, the state"
section: concepts
address: /concepts/accessibilityaudit
contract: 0476e35e6e275db5
---

# AccessibilityAudit

the audit of one rendering against the bar: the rules run, the violations by rule with the element, the state

[figure: AccessibilityAudit is a fact at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | platform |
| key | the rendering |
| store | postgres |
| family | interfaces |



## Fields


| field | type | required | note |
|---|---|---|---|
| `rendering` | `id` | yes |  |
| `standard` | `text` | yes | WCAG 2.2 AA |
| `rules_run` | `count` | yes |  |
| `violations` | `[json]` | yes | rule, element, why |
| `state` | `one of passed \| failed` | yes |  |



## Routes that use it
No route takes or returns AccessibilityAudit directly. The record holds it, and the objects that point at it reach it.


---
title: "AccessMethod"
description: "one access method for one source: its kind, transport, credential kind, proxy policy, depth, rate, politeness, cost and contract"
section: concepts
address: /concepts/accessmethod
contract: 0476e35e6e275db5
---

# AccessMethod

one access method for one source: its kind, transport, credential kind, proxy policy, depth, rate, politeness, cost and contract

[figure: AccessMethod is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | the source and the kind |
| store | postgres |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes | the way's name: its source and its kind, as one name, which a job and a backfill name it by |
| `source` | [Source](/concepts/source) | yes |  |
| `kind` | `one of a bulk file \| an official interface \| a public page \| a licensed file \| a signed-in session \| a person's own browser` | yes | the method, as the field says it |
| `transport` | [TransportKind](/concepts/transportkind) | yes | one shared client; a connector never speaks it |
| `credential_kind` | `one of none \| an API key \| a bearer token \| OAuth 2 \| OAuth 1 \| basic \| a signed request \| a service account \| a client certificate \| an SSH key \| a webhook secret \| a signed-in identity \| the person's own signed-in session` | yes | the person's own signed-in session is the credential of a person's own browser: the capture extension reads under it as that person, and it is never lent (18 §2.2); a signed-in identity is a held identity that the platform keeps |
| `proxy_policy` | [ProxyPolicy](/concepts/proxypolicy) | no |  |
| `depth` | `text` | yes |  |
| `rate` | [RateBound](/concepts/ratebound) | yes | numeric, or the way is unplannable |
| `contract` | [WayContract](/concepts/waycontract) | yes |  |
| `units_yielded` | [SourceObject](/concepts/sourceobject) | yes |  |
| `addressed_by` | `one of a channel \| a query \| a file` | yes | how the way names what it reads, the addressing that bounds each fetch (18 §2.1): a channel is a standing place that the source publishes into, such as a community, an account, a feed or a page that a person opens, and the way reads what appears there; a query is a question that the source returns results for, such as a search or an interface call with filters; a file is a whole file or dump that the way names by its address, such as a monthly dump or a held catalogue |
| `coverage_window` | [Window](/concepts/window) | no |  |
| `legality` | `one of allowed \| not allowed \| paid \| unknown` | yes | follows the legality tier of the way's source: unknown while that tier is unknown, rejected or unusable, and not allowed while the tier is not allowed; a way with no row is not allowed |
| `limits` | `{text:count}` | yes | per-call limits as data |
| `host` | `one of the acquisition system \| the connector host \| the capture extension` | yes |  |



## Routes that use it
No route takes or returns AccessMethod directly. The record holds it, and the objects that point at it reach it.


---
title: "AccessScope"
description: "a name an application asks for, and the permissions it stands for; it only narrows"
section: concepts
address: /concepts/accessscope
contract: 0476e35e6e275db5
---

# AccessScope

a name an application asks for, and the permissions it stands for; it only narrows

[figure: AccessScope is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | its name |
| store | postgres |
| family | people |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `permissions` | [Permission](/concepts/permission) | yes |  |
| `holds` | [AccessScope](/concepts/accessscope) | yes | the narrower ones inside it |
| `plain_words` | `text` | yes | what it allows, shown on the consent screen |



## Routes that use it
No route takes or returns AccessScope directly. The record holds it, and the objects that point at it reach it.


---
title: "AcquisitionPlan"
description: "what one beat issued and declined, adding up to its budget"
section: concepts
address: /concepts/acquisitionplan
contract: 0476e35e6e275db5
---

# AcquisitionPlan

what one beat issued and declined, adding up to its budget

[figure: AcquisitionPlan is a fact at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | follows |
| key | the plane and the beat |
| store | postgres |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `plane` | [Plane](/concepts/plane) | yes |  |
| `beat` | [Beat](/concepts/beat) | yes |  |
| `issued` | `[id]` | yes |  |
| `declined` | [DeclinedCell](/concepts/declinedcell) | yes |  |
| `budget` | [Cost](/concepts/cost) | yes |  |



## Routes that use it
No route takes or returns AcquisitionPlan directly. The record holds it, and the objects that point at it reach it.


---
title: "Action"
description: "one action of a move, run only through the permission check, with its inverse captured first"
section: concepts
address: /concepts/action
contract: 0476e35e6e275db5
---

# Action

one action of a move, run only through the permission check, with its inverse captured first

[figure: Action is a work at strategy scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | work |
| scope | strategy |
| key | the move and its step |
| store | postgres |
| family | strategy |



## Fields


| field | type | required | note |
|---|---|---|---|
| `move` | `id` | yes |  |
| `step` | `count` | yes |  |
| `kind` | [KindOfAction](/concepts/kindofaction) | yes |  |
| `what` | `text` | yes |  |
| `reach` | `text` | yes |  |
| `arguments` | [ActionArgument](/concepts/actionargument) | yes | each with where its value came from |
| `identity` | `id` | yes |  |
| `inverse` | `text` | yes |  |
| `cost` | [Cost](/concepts/cost) | yes |  |
| `allowed_by` | [PermissionAnswer](/concepts/permissionanswer) | no |  |
| `ran_at` | `time` | no |  |
| `undone_by` | `id` | no |  |



## Routes that use it
- [`/v1/act/run_action`](/reference/act/run_action) returns it


---
title: "ActionArgument"
description: "an argument and where its value came from"
section: concepts
address: /concepts/actionargument
contract: 0476e35e6e275db5
---

# ActionArgument

an argument and where its value came from

[figure: ActionArgument is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | strategy |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `value` | `json` | yes |  |
| `came_from` | `one of the record by id \| a definition \| a person's own words` | yes |  |
| `ref` | `id` | no |  |



## Routes that use it
No route takes or returns ActionArgument directly. The record holds it, and the objects that point at it reach it.


---
title: "ActionAudit"
description: "one row per action run through a connector: the move, the grant, the identity that served it, the arguments' sources, the source's own id for what was done, and the inverse"
section: concepts
address: /concepts/actionaudit
contract: 0476e35e6e275db5
---

# ActionAudit

one row per action run through a connector: the move, the grant, the identity that served it, the arguments' sources, the source's own id for what was done, and the inverse

[figure: ActionAudit is a fact at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | follows |
| key | the move |
| store | postgres+lake |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `move` | `id` | yes |  |
| `grant` | `id` | yes |  |
| `mode` | `one of read only \| propose \| act \| full autonomy` | yes |  |
| `identity` | `id` | yes |  |
| `argument_sources` | `{text:text}` | yes |  |
| `source_own_id` | `text` | no |  |
| `inverse` | `text` | no | captured first |



## Routes that use it
No route takes or returns ActionAudit directly. The record holds it, and the objects that point at it reach it.


---
title: "Actor"
description: "a player of the strategy's game: one view over a user with a role held, a voice that speaks for the brand, or a held identity, with its accounts, the kinds of action it may take, its grant, its standing and its capacity"
section: concepts
address: /concepts/actor
contract: 0476e35e6e275db5
---

# Actor

a player of the strategy's game: one view over a user with a role held, a voice that speaks for the brand, or a held identity, with its accounts, the kinds of action it may take, its grant, its standing and its capacity

[figure: Actor is a view at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | none |
| key | none |
| store | none |
| family | strategy |



## Fields


| field | type | required | note |
|---|---|---|---|
| `kind` | `one of a user \| a voice \| a held identity` | yes |  |
| `unit` | `id` | yes | the RoleHeld, the Voice or the held identity |
| `brand` | `id` | yes |  |
| `accounts` | `[id]` | yes | the platform accounts it speaks through |
| `kinds_of_action` | [KindOfAction](/concepts/kindofaction) | yes |  |
| `grant` | `id` | no | the grant that bounds it; absent reads not allowed |
| `standing` | `text` | yes | the sending identity's standing, read from the record |
| `capacity` | `count` | yes | the moves it may carry in the window, a stock |
| `outcomes` | `count` | yes | the outcomes of its record that the propensity is calibrated on |



## Routes that use it
No route takes or returns Actor directly. The record holds it, and the objects that point at it reach it.


---
title: "ActThroughConnectorInput"
description: "run one kind of action with its arguments and their sources"
section: concepts
address: /concepts/actthroughconnectorinput
contract: 0476e35e6e275db5
---

# ActThroughConnectorInput

run one kind of action with its arguments and their sources

[figure: ActThroughConnectorInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `installed_connector` | `id` | yes |  |
| `kind_of_action` | `id` | yes |  |
| `arguments` | `{text:json}` | yes |  |
| `argument_sources` | `{text:text}` | yes | the record by id, a definition, a person's own words |



## Routes that use it
- [`/v1/act/act_through_connector`](/reference/act/act_through_connector) takes it as input


---
title: "AgentMessage"
description: "the words the agent answers a turn with, from the model row that served"
section: concepts
address: /concepts/agentmessage
contract: 0476e35e6e275db5
---

# AgentMessage

the words the agent answers a turn with, from the model row that served

[figure: AgentMessage is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `text` | `text` | yes |  |
| `model` | `text` | no | the model row that answered, by name; absent when the words are the platform's own |



## Routes that use it
No route takes or returns AgentMessage directly. The record holds it, and the objects that point at it reach it.


---
title: "Alarm"
description: "the law or the level it reads, the threshold, who is told, the runbook"
section: concepts
address: /concepts/alarm
contract: 0476e35e6e275db5
---

# Alarm

the law or the level it reads, the threshold, who is told, the runbook

[figure: Alarm is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | its name |
| store | postgres |
| family | operations |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `reads` | `text` | yes |  |
| `threshold` | `json` | yes |  |
| `tells` | `[id]` | yes |  |
| `runbook` | `text` | yes |  |



## Routes that use it
No route takes or returns Alarm directly. The record holds it, and the objects that point at it reach it.


---
title: "AlarmRaising"
description: "one raising of an alarm"
section: concepts
address: /concepts/alarmraising
contract: 0476e35e6e275db5
---

# AlarmRaising

one raising of an alarm

[figure: AlarmRaising is a work at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | work |
| scope | platform |
| key | the alarm and the moment |
| store | postgres |
| family | operations |



## Fields


| field | type | required | note |
|---|---|---|---|
| `alarm` | [Alarm](/concepts/alarm) | yes |  |
| `read` | `json` | yes |  |
| `acknowledged_by` | [Caller](/concepts/caller) | no |  |



## Routes that use it
No route takes or returns AlarmRaising directly. The record holds it, and the objects that point at it reach it.


---
title: "Allowance"
description: "one kind of usage a tier includes, with the quantity"
section: concepts
address: /concepts/allowance
contract: 0476e35e6e275db5
---

# Allowance

one kind of usage a tier includes, with the quantity

[figure: Allowance is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | one allowance of a tier |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `kind` | [KindOfUsage](/concepts/kindofusage) | yes |  |
| `included` | `count` | yes | in the kind's unit |



## Routes that use it
No route takes or returns Allowance directly. The record holds it, and the objects that point at it reach it.


---
title: "Annotation"
description: "one thing a person states about a subject of the record, from any face: the capture panel while a page is captured, the web shell or the desktop shell on an entity's page, the agent in a conversation, or the API."
section: concepts
address: /concepts/annotation
contract: 0476e35e6e275db5
---

# Annotation

one thing a person states about a subject of the record, from any face: the capture panel while a page is captured, the web shell or the desktop shell on an entity's page, the agent in a conversation, or the API.

[figure: Annotation is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `target` | `one of the page \| an item \| a contact \| a region \| an entity` | yes | an entity when the annotation is made on an entity's page or by the agent, with the entity in subject |
| `subject` | `id` | no | the entity the annotation is about when the target is an entity; absent on a page, whose subject the capture supplies |
| `said_in` | `one of the capture panel \| the web shell \| the desktop shell \| the agent \| the API` | no | the face the person said it in; absent means the capture panel |
| `item_field` | `text` | no | the list field the item belongs to |
| `item_key` | `text` | no | the item's own id, or its index |
| `contact` | `text` | no | the contact's namespace and normalised value, joined by a bar |
| `region_selector` | `text` | no | a selector path to the picked element |
| `region_text` | `text` | no | the picked element's visible text |
| `kind` | `one of a tag \| a relation \| a note \| a rival \| a fit \| a membership \| a kind of thing` | yes | a rival marks the subject as competing with one of the tenant's brands; a fit states it fits a kind of buyer; a membership places it in a facet, a vertical, a segment or a community; a kind of thing says what the subject is |
| `register` | `text` | no | the place of the record the unit was found in (kinds of buyer, brands, offerings, facets, verticals, concepts, segments, communities, entities) |
| `value` | `text` | yes | the tag's name, the relation's kind of connection or the person's own words for it, the note, or the kind of entity |
| `entity` | `id` | no | the unit of the record it points at; absent for a thing the record does not hold yet |
| `entity_name` | `text` | no | the unit's name, or the name of a new thing |
| `entity_kind` | `text` | no | the unit's kind, or the kind of entity the person set for a new thing |
| `role` | `text` | no | for a relation: the role the page's subject takes |
| `stated_at` | `time` | yes |  |



## Routes that use it
- [`/v1/act/annotate`](/reference/act/annotate) takes it as input


---
title: "Answer"
description: "what every operation gives: the value, its population, and for every count which of the three positions it is in"
section: concepts
address: /concepts/answer
contract: 0476e35e6e275db5
---

# Answer

what every operation gives: the value, its population, and for every count which of the three positions it is in

[figure: Answer is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | gateway |



## Fields


| field | type | required | note |
|---|---|---|---|
| `card` | [Card](/concepts/card) | yes |  |
| `refusal` | [Refusal](/concepts/refusal) | no |  |
| `task` | `id` | no | for a long step |



## Routes that use it
No route takes or returns Answer directly. The record holds it, and the objects that point at it reach it.


---
title: "Application"
description: "one customer question the platform can answer over a vertical, with what it needs, what it gives, and the check that would show it wrong"
section: concepts
address: /concepts/application
contract: 0476e35e6e275db5
---

# Application

one customer question the platform can answer over a vertical, with what it needs, what it gives, and the check that would show it wrong

[figure: Application is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | its name |
| store | postgres |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `customer_question` | `text` | yes |  |
| `inputs` | `[text]` | yes |  |
| `outputs` | `[text]` | yes | the surfaces it lands on |
| `context_modes` | `[one of the platform's own offering \| a customer's brand \| an agency's client \| a person's own workspace]` | yes |  |
| `failure_checks` | `[text]` | yes |  |
| `state` | [Readiness](/concepts/readiness) | yes |  |



## Routes that use it
No route takes or returns Application directly. The record holds it, and the objects that point at it reach it.


---
title: "ApprovalRequest"
description: "a request the server raises when the permission check's verdict is propose: the action, its inverse, the verdict and the reason; the turn waits for the client's answer"
section: concepts
address: /concepts/approvalrequest
contract: 0476e35e6e275db5
---

# ApprovalRequest

a request the server raises when the permission check's verdict is propose: the action, its inverse, the verdict and the reason; the turn waits for the client's answer

[figure: ApprovalRequest is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `id` | `id` | yes |  |
| `action` | `text` | yes |  |
| `inverse` | `text` | no |  |
| `verdict` | [PermissionAnswer](/concepts/permissionanswer) | yes |  |
| `reason` | `text` | yes |  |
| `answer` | `one of allow \| deny \| allow-for-session` | no |  |
| `answered_by` | [Caller](/concepts/caller) | no |  |



## Routes that use it
No route takes or returns ApprovalRequest directly. The record holds it, and the objects that point at it reach it.


---
title: "ArgumentDeclaration"
description: "one argument of a kind of action, and where its value may come from"
section: concepts
address: /concepts/argumentdeclaration
contract: 0476e35e6e275db5
---

# ArgumentDeclaration

one argument of a kind of action, and where its value may come from

[figure: ArgumentDeclaration is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `type` | `text` | yes |  |
| `may_come_from` | `one of the record by id \| a definition \| a person's own words \| a model's answer never` | yes |  |



## Routes that use it
No route takes or returns ArgumentDeclaration directly. The record holds it, and the objects that point at it reach it.


---
title: "Arming"
description: "a definition pointing at a cell and raising its value"
section: concepts
address: /concepts/arming
contract: 0476e35e6e275db5
---

# Arming

a definition pointing at a cell and raising its value

[figure: Arming is a fact at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | follows |
| key | the definition's version, with the cell's key |
| store | postgres |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `definition` | `id` | yes |  |
| `definition_version` | `count` | yes |  |
| `cell` | `id` | yes |  |
| `value` | `share` | yes |  |
| `disarmed_by` | `id` | no |  |



## Routes that use it
No route takes or returns Arming directly. The record holds it, and the objects that point at it reach it.


---
title: "ArmMonitorInput"
description: "the monitor's version, and for arming the preview it was judged by"
section: concepts
address: /concepts/armmonitorinput
contract: 0476e35e6e275db5
---

# ArmMonitorInput

the monitor's version, and for arming the preview it was judged by

[figure: ArmMonitorInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `monitor` | `id` | yes |  |
| `version` | `count` | yes |  |
| `arm` | `bool` | yes |  |
| `preview` | `id` | no | required to arm |



## Routes that use it
- [`/v1/act/arm_monitor`](/reference/act/arm_monitor) takes it as input


---
title: "ArmPlayAnswer"
description: "the armed play, and the cells of demand it raised"
section: concepts
address: /concepts/armplayanswer
contract: 0476e35e6e275db5
---

# ArmPlayAnswer

the armed play, and the cells of demand it raised

[figure: ArmPlayAnswer is a view at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `play` | [Play](/concepts/play) | yes |  |
| `cells` | `[id]` | yes |  |



## Routes that use it
- [`/v1/act/arm_play`](/reference/act/arm_play) returns it


---
title: "ArmPlayInput"
description: "the play, inside a strategy, for a brand, and the share it is armed on with its holdout: a share under one makes the play an experiment"
section: concepts
address: /concepts/armplayinput
contract: 0476e35e6e275db5
---

# ArmPlayInput

the play, inside a strategy, for a brand, and the share it is armed on with its holdout: a share under one makes the play an experiment

[figure: ArmPlayInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `play` | `id` | yes |  |
| `strategy` | `id` | yes |  |
| `brand` | `id` | yes |  |
| `arm` | `bool` | yes |  |
| `share` | `share` | no | the share of the admitted members the arming admits; absent keeps the play's own |
| `holdout` | `share` | no | the share left alone at random, read as the effect's comparison; absent keeps the play's own |



## Routes that use it
- [`/v1/act/arm_play`](/reference/act/arm_play) takes it as input


---
title: "Artefact"
description: "the single artefact generated from every register, built into types in both repositories"
section: concepts
address: /concepts/artefact
contract: 0476e35e6e275db5
---

# Artefact

the single artefact generated from every register, built into types in both repositories

[figure: Artefact is a definition at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | platform |
| key | the hash of its content |
| store | postgres |
| family | registers |



## Fields


| field | type | required | note |
|---|---|---|---|
| `hash` | `hash` | yes | over its registers' rows |
| `register_hash` | `hash` | yes | the type register it was generated with |
| `registers` | [Register](/concepts/register) | yes |  |
| `built_at` | `time` | yes |  |
| `pinned_by` | `[text]` | yes | the repositories and the versions that pin it |



## Routes that use it
No route takes or returns Artefact directly. The record holds it, and the objects that point at it reach it.


---
title: "Ask"
description: "one ask of one way for one cell, with its cost, its risk and a deadline"
section: concepts
address: /concepts/ask
contract: 0476e35e6e275db5
---

# Ask

one ask of one way for one cell, with its cost, its risk and a deadline

[figure: Ask is a work at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | work |
| scope | follows |
| key | the plan, the cell and the way |
| store | postgres |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `plan` | `id` | yes |  |
| `cell` | `id` | yes |  |
| `way` | [AccessMethod](/concepts/accessmethod) | yes |  |
| `cost` | [Cost](/concepts/cost) | yes |  |
| `risk` | `text` | yes |  |
| `deadline` | `time` | no |  |
| `decided_by` | [Caller](/concepts/caller) | no |  |



## Routes that use it
- [`/v1/act/decide_ask`](/reference/act/decide_ask) returns it


---
title: "AssignInput"
description: "the lead and the user; by hand, or hand on"
section: concepts
address: /concepts/assigninput
contract: 0476e35e6e275db5
---

# AssignInput

the lead and the user; by hand, or hand on

[figure: AssignInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `lead` | `id` | yes |  |
| `user` | `id` | yes |  |
| `reason` | `text` | yes |  |



## Routes that use it
- [`/v1/act/assign`](/reference/act/assign) takes it as input


---
title: "Assignment"
description: "which members a move touched and which it left alone, written before the first action"
section: concepts
address: /concepts/assignment
contract: 0476e35e6e275db5
---

# Assignment

which members a move touched and which it left alone, written before the first action

[figure: Assignment is a fact at strategy scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | strategy |
| key | the move, the member and the group |
| store | postgres+lake |
| family | record |



## Fields


| field | type | required | note |
|---|---|---|---|
| `move` | `id` | yes |  |
| `member` | `id` | yes |  |
| `group` | `one of touched \| left alone` | yes |  |
| `chosen_at` | `time` | yes |  |
| `replaces` | `id` | no | a member that changes group later is a new fact that names the first |



## Routes that use it
No route takes or returns Assignment directly. The record holds it, and the objects that point at it reach it.


---
title: "Assumption"
description: "one assumption a business model discloses, and the driver it rests on"
section: concepts
address: /concepts/assumption
contract: 0476e35e6e275db5
---

# Assumption

one assumption a business model discloses, and the driver it rests on

[figure: Assumption is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | one assumption a model discloses |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `text` | `text` | yes |  |
| `rests_on` | [KindOfMeasure](/concepts/kindofmeasure) | yes |  |



## Routes that use it
No route takes or returns Assumption directly. The record holds it, and the objects that point at it reach it.


---
title: "Attainability"
description: "learned from jobs that failed: whether a thing can be reached"
section: concepts
address: /concepts/attainability
contract: 0476e35e6e275db5
---

# Attainability

learned from jobs that failed: whether a thing can be reached

[figure: Attainability is a fact at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | follows |
| key | the connector, the source object and the domain |
| store | postgres+lake |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `connector` | [Connector](/concepts/connector) | yes |  |
| `source_object` | [SourceObject](/concepts/sourceobject) | yes |  |
| `domain` | `text` | yes |  |
| `attainable` | `one of yes \| no \| unknown` | yes |  |
| `reason` | `text` | no |  |



## Routes that use it
No route takes or returns Attainability directly. The record holds it, and the objects that point at it reach it.


---
title: "Attempt"
description: "one try of a job, a run keyed by the unit and the attempt's number"
section: concepts
address: /concepts/attempt
contract: 0476e35e6e275db5
---

# Attempt

one try of a job, a run keyed by the unit and the attempt's number

[figure: Attempt is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | kernel |



## Fields


| field | type | required | note |
|---|---|---|---|
| `number` | `count` | yes |  |
| `run` | `id` | yes |  |
| `outcome` | `one of done \| failed \| stopped` | yes |  |
| `failure_class` | [FailureClass](/concepts/failureclass) | no | only a failure of the unit's own class counts against it |



## Routes that use it
No route takes or returns Attempt directly. The record holds it, and the objects that point at it reach it.


---
title: "AttributeCount"
description: "one attribute a population's units carry: its path, its plain name, how many units carry it and the value type that was read"
section: concepts
address: /concepts/attributecount
contract: 0476e35e6e275db5
---

# AttributeCount

one attribute a population's units carry: its path, its plain name, how many units carry it and the value type that was read

[figure: AttributeCount is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | rules_engine |



## Fields


| field | type | required | note |
|---|---|---|---|
| `path` | `text` | yes | the attribute path a condition names |
| `plain_words` | `text` | yes | the name a composer shows |
| `units` | `count` | yes | the units that carry a value |
| `value_type` | `text` | yes | text, number, time, yes or no, list, or mixed |
| `examples` | `[text]` | yes | up to three values, the most common first |



## Routes that use it
No route takes or returns AttributeCount directly. The record holds it, and the objects that point at it reach it.


---
title: "AttributesInput"
description: "which population's attributes to read"
section: concepts
address: /concepts/attributesinput
contract: 0476e35e6e275db5
---

# AttributesInput

which population's attributes to read

[figure: AttributesInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | rules_engine |



## Fields


| field | type | required | note |
|---|---|---|---|
| `population` | [Population](/concepts/population) | yes |  |
| `window` | [Window](/concepts/window) | no | the units read; the whole record when absent |



## Routes that use it
- [`/v1/read/attributes`](/reference/read/attributes) takes it as input


---
title: "AudienceMapCell"
description: "the shared subjects, the share, the lift, the window and the negative control, with the size as bounds"
section: concepts
address: /concepts/audiencemapcell
contract: 0476e35e6e275db5
---

# AudienceMapCell

the shared subjects, the share, the lift, the window and the negative control, with the size as bounds

[figure: AudienceMapCell is a view at brand scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | brand |
| key | two facets or a facet and a community, and the window |
| store | derived |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `first` | `id` | yes |  |
| `second` | `id` | yes |  |
| `window` | [Window](/concepts/window) | yes |  |
| `shared` | `count` | no | null when never read |
| `share` | `share` | no |  |
| `lift` | `share` | no |  |
| `control` | `share` | no | must read near one |
| `lower` | `count` | no |  |
| `upper` | `count` | no |  |
| `mode` | `one of present \| to be cultivated \| unknown` | no | the demand mode read from the cell |



## Routes that use it
- [`/v1/read/audience_map`](/reference/read/audience_map) returns it


---
title: "AudienceMapInput"
description: "a brand, two facets or a facet and a community, the window"
section: concepts
address: /concepts/audiencemapinput
contract: 0476e35e6e275db5
---

# AudienceMapInput

a brand, two facets or a facet and a community, the window

[figure: AudienceMapInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `brand` | `id` | yes |  |
| `first` | `id` | yes |  |
| `second` | `id` | yes |  |
| `window` | [Window](/concepts/window) | yes |  |
| `adult` | `bool` | no | when true, the rooms marked adult count in the crossing; left out by default |



## Routes that use it
- [`/v1/read/audience_map`](/reference/read/audience_map) takes it as input


---
title: "Backfill"
description: "one backfill of a source over a window, read in blocks with a ledger row (a Job) each: what it reads, by which way, at which code version, from a parse already made by the connector's own implementation where one is held, and how far it has got"
section: concepts
address: /concepts/backfill
contract: 0476e35e6e275db5
---

# Backfill

one backfill of a source over a window, read in blocks with a ledger row (a Job) each: what it reads, by which way, at which code version, from a parse already made by the connector's own implementation where one is held, and how far it has got

[figure: Backfill is a work at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | work |
| scope | platform |
| key | the source, the way and the window |
| store | postgres |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `source` | [Source](/concepts/source) | yes |  |
| `way` | [AccessMethod](/concepts/accessmethod) | yes |  |
| `window` | [Window](/concepts/window) | yes |  |
| `plane` | [Plane](/concepts/plane) | yes |  |
| `blocks` | `count` | yes | the blocks of the window, one a month for a monthly archive |
| `blocks_done` | `count` | yes |  |
| `code_version` | `text` | yes | the refine's code version: the parser's commit, or the release |
| `held_parse` | [SourceProcedure](/concepts/sourceprocedure) | no | Names the source procedure that records the folder that the connector's own parser wrote before the platform ran. The engine reads that folder in place (18 §2.25). Absent when the platform parses the block itself. |



## Routes that use it
No route takes or returns Backfill directly. The record holds it, and the objects that point at it reach it.


---
title: "BackfillInput"
description: "a source, an access method, a window and a plane; the platform fills the reading, so the same request over a catalogue read again is new work"
section: concepts
address: /concepts/backfillinput
contract: 0476e35e6e275db5
---

# BackfillInput

a source, an access method, a window and a plane; the platform fills the reading, so the same request over a catalogue read again is new work

[figure: BackfillInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `source` | `id` | yes |  |
| `access_method` | `id` | yes |  |
| `window` | [Window](/concepts/window) | yes |  |
| `plane` | [Plane](/concepts/plane) | yes |  |
| `reading` | `text` | no | the hash of the procedure reading the backfill runs over, filled by the platform from the newest reading of the source through the way's connector; a caller leaves it empty |



## Routes that use it
- [`/v1/work/backfill`](/reference/work/backfill) takes it as input


---
title: "Backup"
description: "the daily verified backup of the database, with the lakehouse's catalogue and manifest beside it"
section: concepts
address: /concepts/backup
contract: 0476e35e6e275db5
---

# Backup

the daily verified backup of the database, with the lakehouse's catalogue and manifest beside it

[figure: Backup is a work at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | work |
| scope | platform |
| key | the day |
| store | postgres |
| family | operations |



## Fields


| field | type | required | note |
|---|---|---|---|
| `day` | `date` | yes |  |
| `copy` | `text` | yes |  |
| `bytes` | `bytes` | yes |  |
| `tables` | `count` | yes |  |
| `discrepancies` | `count` | yes | ready only at zero |
| `rows` | `count` | yes | the rows the copy holds over its tables, as the verifier counted them |
| `log_hash` | `hash` | yes | the hash of the log inside the copy, as the verifier read it; the drill compares against it |
| `lake_manifest` | [LakeFile](/concepts/lakefile) | yes |  |
| `made_at` | `time` | yes |  |



## Routes that use it
No route takes or returns Backup directly. The record holds it, and the objects that point at it reach it.


---
title: "BarsOfNearness"
description: "the value of the parameter *the bars of nearness*: the bars of each breadth, read by the grounding on every channel and by the compiler when a leaf names a breadth, through one resolver"
section: concepts
address: /concepts/barsofnearness
contract: 0476e35e6e275db5
---

# BarsOfNearness

the value of the parameter *the bars of nearness*: the bars of each breadth, read by the grounding on every channel and by the compiler when a leaf names a breadth, through one resolver

[figure: BarsOfNearness is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | rules_engine |



## Fields


| field | type | required | note |
|---|---|---|---|
| `exact` | [NearnessBar](/concepts/nearnessbar) | yes |  |
| `similar` | [NearnessBar](/concepts/nearnessbar) | yes |  |
| `related` | [NearnessBar](/concepts/nearnessbar) | yes |  |
| `broad` | [NearnessBar](/concepts/nearnessbar) | yes |  |
| `model` | [Model](/concepts/model) | no | the model the meaning bars were measured under; a meaning leaf under another model refuses, and unmeasured bars admit no breadth |
| `measured_at` | `time` | no |  |
| `basis` | `text` | no | how the meaning bars were measured: the population, the probes, the shares and the spread across probes |
| `by_concept` | [ConceptBars](/concepts/conceptbars) | no | the bars of each probe on its own; a leaf whose concept is among them takes its own bar, and one whose concept is not takes the median bar |



## Routes that use it
No route takes or returns BarsOfNearness directly. The record holds it, and the objects that point at it reach it.


---
title: "Basis"
description: "how well founded a fact or a number is"
section: concepts
address: /concepts/basis
contract: 0476e35e6e275db5
---

# Basis

how well founded a fact or a number is

[figure: Basis is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | kernel |



## Fields


| field | type | required | note |
|---|---|---|---|
| `basis` | `one of observed \| stated by a source \| derived by a named rule \| estimated with an interval \| measured \| inferred \| never measured` | yes |  |
| `rule` | `text` | no | the named rule, for derived |
| `interval` | [Interval](/concepts/interval) | no | for estimated |



## Routes that use it
No route takes or returns Basis directly. The record holds it, and the objects that point at it reach it.


---
title: "BasketCell"
description: "one proxy against one group: the count, the share, the lift against the base rate and the negative control"
section: concepts
address: /concepts/basketcell
contract: 0476e35e6e275db5
---

# BasketCell

one proxy against one group: the count, the share, the lift against the base rate and the negative control

[figure: BasketCell is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | rules_engine |



## Fields


| field | type | required | note |
|---|---|---|---|
| `proxy` | `id` | yes |  |
| `group` | `id` | yes |  |
| `count` | [Summary](/concepts/summary) | yes |  |
| `share` | `share` | yes |  |
| `lift` | `share` | yes | against the base rate over the whole population |
| `control` | [ControlResult](/concepts/controlresult) | yes |  |



## Routes that use it
No route takes or returns BasketCell directly. The record holds it, and the objects that point at it reach it.


---
title: "BasketReading"
description: "a basket read over one subject, a set or groups, kept as a fact and armed over its population"
section: concepts
address: /concepts/basketreading
contract: 0476e35e6e275db5
---

# BasketReading

a basket read over one subject, a set or groups, kept as a fact and armed over its population

[figure: BasketReading is a fact at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | follows |
| key | the basket version, the population and the window |
| store | postgres+lake |
| family | rules_engine |



## Fields


| field | type | required | note |
|---|---|---|---|
| `basket` | `id` | yes |  |
| `version` | `count` | yes |  |
| `population` | [PopulationStatement](/concepts/populationstatement) | yes |  |
| `window` | [Window](/concepts/window) | yes |  |
| `memberships` | [ProxyMembership](/concepts/proxymembership) | no | over one subject |
| `readings` | [ProxyReading](/concepts/proxyreading) | no | over a set, one per proxy |
| `co_membership` | `[json]` | no | proxy, proxy, shared count |
| `cells` | [BasketCell](/concepts/basketcell) | no | over groups |
| `as_of` | [TwoDates](/concepts/twodates) | yes |  |
| `changed` | [NumberChange](/concepts/numberchange) | no | against the reading before |



## Routes that use it
- [`/v1/read/basket`](/reference/read/basket) returns it


---
title: "BasketReadInput"
description: "a basket and what to read it over: one subject, a set, a scope or a cut into groups, with the window"
section: concepts
address: /concepts/basketreadinput
contract: 0476e35e6e275db5
---

# BasketReadInput

a basket and what to read it over: one subject, a set, a scope or a cut into groups, with the window

[figure: BasketReadInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `basket` | `id` | yes |  |
| `subject` | `id` | no | one subject |
| `subjects` | `[id]` | no | a set, under the size bound |
| `scope` | [Predicate](/concepts/predicate) | no | a population by predicate |
| `resolution` | `share` | no | a cut into groups at this resolution |
| `window` | [Window](/concepts/window) | no |  |



## Routes that use it
- [`/v1/read/basket`](/reference/read/basket) takes it as input


---
title: "Beat"
description: "when something runs again; one register and one scheduler"
section: concepts
address: /concepts/beat
contract: 0476e35e6e275db5
---

# Beat

when something runs again; one register and one scheduler

[figure: Beat is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | its name |
| store | postgres |
| family | rules_engine |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `every` | `duration` | yes |  |
| `anchor` | `time` | no |  |
| `zone` | `text` | no |  |
| `attempts` | `count` | no | how many attempts one tick gets before its run is left failed; absent means one, so a failed tick waits for the next |
| `retry_after` | `duration` | no | the wait between a failed attempt and the next; required when attempts is above one |



## Routes that use it
- [`/v1/act/beat`](/reference/act/beat) returns it


---
title: "BeatBudget"
description: "the beat's budget: the units a tick may evaluate and the definitions it may start; the rest wait for the next tick, oldest first, one tenant after another"
section: concepts
address: /concepts/beatbudget
contract: 0476e35e6e275db5
---

# BeatBudget

the beat's budget: the units a tick may evaluate and the definitions it may start; the rest wait for the next tick, oldest first, one tenant after another

[figure: BeatBudget is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | rules_engine |



## Fields


| field | type | required | note |
|---|---|---|---|
| `units` | `count` | yes |  |
| `definitions` | `count` | yes |  |



## Routes that use it
No route takes or returns BeatBudget directly. The record holds it, and the objects that point at it reach it.


---
title: "BeatInput"
description: "a beat to write"
section: concepts
address: /concepts/beatinput
contract: 0476e35e6e275db5
---

# BeatInput

a beat to write

[figure: BeatInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `beat` | [Beat](/concepts/beat) | yes |  |



## Routes that use it
- [`/v1/act/beat`](/reference/act/beat) takes it as input


---
title: "Benchmark"
description: "a published or platform-derived number for a value driver over a stated population and period, with its interval and the rights its source allows; never read by an estimate without all four"
section: concepts
address: /concepts/benchmark
contract: 0476e35e6e275db5
---

# Benchmark

a published or platform-derived number for a value driver over a stated population and period, with its interval and the rights its source allows; never read by an estimate without all four

[figure: Benchmark is a fact at shared scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | shared |
| key | its driver, its population, its period and its source |
| store | lake:ready |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `driver` | [KindOfMeasure](/concepts/kindofmeasure) | yes |  |
| `value` | [Interval](/concepts/interval) | yes | the point with its interval at its level; a point alone carries lower and upper equal to it and says so in the basis |
| `population` | [BenchmarkPopulation](/concepts/benchmarkpopulation) | yes |  |
| `period` | [Window](/concepts/window) | yes | the period the number is about |
| `applies_to` | [UnitRef](/concepts/unitref) | yes | the buyer profiles, segments or verticals it applies to |
| `study` | `text` | yes | the study or dataset, as its publisher names it |
| `publisher` | `text` | yes |  |
| `url` | `address` | no |  |
| `terms` | [Rights](/concepts/rights) | yes | what the source allows: quote, redistribute, use in a product, as the rights row states |



## Routes that use it
No route takes or returns Benchmark directly. The record holds it, and the objects that point at it reach it.


---
title: "BenchmarkPopulation"
description: "who a benchmark measured, as the source states it"
section: concepts
address: /concepts/benchmarkpopulation
contract: 0476e35e6e275db5
---

# BenchmarkPopulation

who a benchmark measured, as the source states it

[figure: BenchmarkPopulation is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | who a benchmark measured |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `who` | `text` | yes | the population in the source's words |
| `count` | `count` | no | the sample or the population size when the source states it |
| `sampling_frame` | `text` | no |  |
| `geography` | `text` | no |  |



## Routes that use it
No route takes or returns BenchmarkPopulation directly. The record holds it, and the objects that point at it reach it.


---
title: "BenchmarksInput"
description: "the driver, and the buyer profile or population the benchmarks must apply to"
section: concepts
address: /concepts/benchmarksinput
contract: 0476e35e6e275db5
---

# BenchmarksInput

the driver, and the buyer profile or population the benchmarks must apply to

[figure: BenchmarksInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | one ask for the benchmarks |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `driver` | [KindOfMeasure](/concepts/kindofmeasure) | yes |  |
| `kind_of_buyer` | `text` | no |  |



## Routes that use it
- [`/v1/economics/benchmarks`](/reference/economics/benchmarks) takes it as input


---
title: "BillingAccount"
description: "the tenant's account with the payment provider: the provider's customer id, the currency, the address, the payment state, the period"
section: concepts
address: /concepts/billingaccount
contract: 0476e35e6e275db5
---

# BillingAccount

the tenant's account with the payment provider: the provider's customer id, the currency, the address, the payment state, the period

[figure: BillingAccount is a row at tenant scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | tenant |
| key | the tenant |
| store | postgres |
| family | operations |



## Fields


| field | type | required | note |
|---|---|---|---|
| `provider` | `text` | yes | the connector package |
| `customer_id` | `text` | yes | the provider's |
| `currency` | `text` | yes |  |
| `address` | `text` | no |  |
| `payment_state` | `one of none \| on file \| failing` | yes |  |
| `period` | `one of monthly \| yearly` | yes |  |



## Routes that use it
No route takes or returns BillingAccount directly. The record holds it, and the objects that point at it reach it.


---
title: "BindBuyerAnswer"
description: "the binding, and the preview of the kind's members"
section: concepts
address: /concepts/bindbuyeranswer
contract: 0476e35e6e275db5
---

# BindBuyerAnswer

the binding, and the preview of the kind's members

[figure: BindBuyerAnswer is a view at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `kind_of_buyer` | [KindOfBuyer](/concepts/kindofbuyer) | yes |  |
| `preview` | [PreviewAnswer](/concepts/previewanswer) | yes |  |



## Routes that use it
- [`/v1/act/bind_buyer`](/reference/act/bind_buyer) returns it


---
title: "BindBuyerInput"
description: "a buyer profile and its bindings"
section: concepts
address: /concepts/bindbuyerinput
contract: 0476e35e6e275db5
---

# BindBuyerInput

a buyer profile and its bindings

[figure: BindBuyerInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `kind_of_buyer` | `id` | yes |  |
| `bindings` | [Binding](/concepts/binding) | yes |  |
| `ladder` | `text` | no | the ladder the kind climbs, by its name, where the binding changes it; the ladder must be kept and ready |



## Routes that use it
- [`/v1/act/bind_buyer`](/reference/act/bind_buyer) takes it as input


---
title: "Binding"
description: "a buyer profile bound to an offering or a segment"
section: concepts
address: /concepts/binding
contract: 0476e35e6e275db5
---

# Binding

a buyer profile bound to an offering or a segment

[figure: Binding is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `offering` | `id` | no |  |
| `segment` | `id` | no |  |
| `weight` | `share` | yes |  |
| `mode` | `one of scored \| required \| disqualifying` | yes |  |
| `condition` | [Predicate](/concepts/predicate) | no | when the binding applies; absent means the whole kind |
| `reason` | `text` | no | required when the mode is disqualifying |
| `sequence` | `count` | no | 1 for the first purchase |



## Routes that use it
No route takes or returns Binding directly. The record holds it, and the objects that point at it reach it.


---
title: "Board"
description: "a board of tiles for an audience, at tenant or platform scope, drawn from saved questions"
section: concepts
address: /concepts/board
contract: 0476e35e6e275db5
---

# Board

a board of tiles for an audience, at tenant or platform scope, drawn from saved questions

[figure: Board is a definition at tenant scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | tenant |
| key | the scope and the name |
| store | postgres |
| family | ops_console |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `audience` | `text` | yes | a role |
| `tiles` | [Tile](/concepts/tile) | yes |  |
| `period` | [Window](/concepts/window) | yes | the default |



## Routes that use it
- [`/v1/act/board`](/reference/act/board) returns it


---
title: "BoardAnswer"
description: "a board with every tile's numbers, each with its basis and its population"
section: concepts
address: /concepts/boardanswer
contract: 0476e35e6e275db5
---

# BoardAnswer

a board with every tile's numbers, each with its basis and its population

[figure: BoardAnswer is a view at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `board` | [Board](/concepts/board) | yes |  |
| `tiles` | `[json]` | yes | tile, numbers with basis and population |



## Routes that use it
- [`/v1/read/board`](/reference/read/board) returns it


---
title: "BoardInput"
description: "a board to write, with its tiles"
section: concepts
address: /concepts/boardinput
contract: 0476e35e6e275db5
---

# BoardInput

a board to write, with its tiles

[figure: BoardInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `audience` | `text` | yes |  |
| `tiles` | [Tile](/concepts/tile) | yes |  |
| `period` | [Window](/concepts/window) | yes |  |



## Routes that use it
- [`/v1/act/board`](/reference/act/board) takes it as input


---
title: "BoardReadInput"
description: "a board to read, over a period"
section: concepts
address: /concepts/boardreadinput
contract: 0476e35e6e275db5
---

# BoardReadInput

a board to read, over a period

[figure: BoardReadInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `board` | `id` | yes |  |
| `period` | [Window](/concepts/window) | no |  |



## Routes that use it
- [`/v1/read/board`](/reference/read/board) takes it as input


---
title: "Brand"
description: "a brand, shared; a tenant's own and a rival are one kind, and the marking is a fact"
section: concepts
address: /concepts/brand
contract: 0476e35e6e275db5
---

# Brand

a brand, shared; a tenant's own and a rival are one kind, and the marking is a fact

[figure: Brand is a entity at shared scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | entity |
| scope | shared |
| key | its owning company and its name |
| store | postgres |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `company` | `id` | yes |  |
| `name` | `text` | yes |  |
| `website` | `text` | yes |  |
| `offerings` | `[id]` | yes |  |
| `accounts` | `[id]` | yes |  |
| `voices` | `[id]` | yes |  |
| `places` | `[id]` | yes |  |
| `markets` | `[id]` | yes |  |
| `zone` | `text` | no | the time zone the brand works in |
| `vertical` | `id` | no |  |
| `segment` | `id` | no |  |
| `template_installed` | [InstalledTemplate](/concepts/installedtemplate) | no |  |
| `position` | [Claim](/concepts/claim) | no | a claim, under test until settled |



## Routes that use it
No route takes or returns Brand directly. The record holds it, and the objects that point at it reach it.


---
title: "BrandAsset"
description: "one file a page loads, held whole in bronze"
section: concepts
address: /concepts/brandasset
contract: 0476e35e6e275db5
---

# BrandAsset

one file a page loads, held whole in bronze

[figure: BrandAsset is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `address` | `address` | yes |  |
| `artefact` | `hash` | yes |  |
| `kind` | `text` | yes | png, jpeg, gif, webp, svg, ico, woff, woff2, ttf, otf, mp4, webm or other, read from the bytes |
| `role` | `one of image \| animated image \| icon \| font \| media` | yes |  |
| `bytes` | `count` | yes |  |
| `width` | `number` | no | read from the file's header, in px |
| `height` | `number` | no |  |
| `basis` | [Basis](/concepts/basis) | yes |  |
| `from` | `[hash]` | yes | the documents and stylesheets that load it |



## Routes that use it
No route takes or returns BrandAsset directly. The record holds it, and the objects that point at it reach it.


---
title: "BrandBorder"
description: "one border width and style declared"
section: concepts
address: /concepts/brandborder
contract: 0476e35e6e275db5
---

# BrandBorder

one border width and style declared

[figure: BrandBorder is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `width` | `number` | yes |  |
| `style` | `text` | yes |  |
| `uses` | `count` | yes |  |
| `basis` | [Basis](/concepts/basis) | yes |  |
| `from` | `[hash]` | yes |  |



## Routes that use it
No route takes or returns BrandBorder directly. The record holds it, and the objects that point at it reach it.


---
title: "BrandBreakpoint"
description: "one width a media query turns on"
section: concepts
address: /concepts/brandbreakpoint
contract: 0476e35e6e275db5
---

# BrandBreakpoint

one width a media query turns on

[figure: BrandBreakpoint is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `px` | `number` | yes |  |
| `edge` | `one of min \| max` | yes |  |
| `uses` | `count` | yes |  |
| `basis` | [Basis](/concepts/basis) | yes |  |
| `from` | `[hash]` | yes |  |



## Routes that use it
No route takes or returns BrandBreakpoint directly. The record holds it, and the objects that point at it reach it.


---
title: "BrandChange"
description: "one value that differs between two versions of a design system"
section: concepts
address: /concepts/brandchange
contract: 0476e35e6e275db5
---

# BrandChange

one value that differs between two versions of a design system

[figure: BrandChange is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `path` | `text` | yes |  |
| `before` | `json` | no |  |
| `after` | `json` | no |  |
| `basis_before` | `text` | no |  |
| `basis_after` | `text` | no |  |



## Routes that use it
No route takes or returns BrandChange directly. The record holds it, and the objects that point at it reach it.


---
title: "BrandColour"
description: "one colour of a brand's site, as one hex value, with where it was read and how well founded it is"
section: concepts
address: /concepts/brandcolour
contract: 0476e35e6e275db5
---

# BrandColour

one colour of a brand's site, as one hex value, with where it was read and how well founded it is

[figure: BrandColour is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `role` | `one of surface \| ink \| accent \| rule \| declared` | yes | a role when the value is one of the four, else a colour the site declares |
| `value` | `text` | yes | the colour as #rrggbb or #rrggbbaa |
| `polarity` | `one of light \| dark` | yes |  |
| `uses` | `count` | yes | the declarations that carry it |
| `properties` | `[text]` | yes | the properties it was declared in |
| `basis` | [Basis](/concepts/basis) | yes |  |
| `from` | `[hash]` | yes | the artefacts it was read from |



## Routes that use it
No route takes or returns BrandColour directly. The record holds it, and the objects that point at it reach it.


---
title: "BrandComponent"
description: "one recurring part of the pages: a class the stylesheet styles as a surface and the pages use"
section: concepts
address: /concepts/brandcomponent
contract: 0476e35e6e275db5
---

# BrandComponent

one recurring part of the pages: a class the stylesheet styles as a surface and the pages use

[figure: BrandComponent is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `selector` | `text` | yes |  |
| `kind` | `one of button \| card \| field \| navigation \| badge \| table \| other` | yes | read from the tag and the class name |
| `uses` | `count` | yes | the elements on the pages held that carry the class |
| `declarations` | `[text]` | yes | each as property: value, the site's variables resolved |
| `basis` | [Basis](/concepts/basis) | yes |  |
| `from` | `[hash]` | yes |  |



## Routes that use it
No route takes or returns BrandComponent directly. The record holds it, and the objects that point at it reach it.


---
title: "BrandCoordinate"
description: "one option of every design axis: where a variant sits"
section: concepts
address: /concepts/brandcoordinate
contract: 0476e35e6e275db5
---

# BrandCoordinate

one option of every design axis: where a variant sits

[figure: BrandCoordinate is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `mode` | [DesignAxis](/concepts/designaxis) | yes | an option of the mode axis |
| `medium` | [DesignAxis](/concepts/designaxis) | yes | an option of the medium axis |
| `density` | [DesignAxis](/concepts/designaxis) | yes | an option of the density axis |
| `contrast` | [DesignAxis](/concepts/designaxis) | yes | an option of the contrast axis |



## Routes that use it
No route takes or returns BrandCoordinate directly. The record holds it, and the objects that point at it reach it.


---
title: "BrandDecision"
description: "a tenant's decision on one value of the brand's design system: accepted, declined, or changed to the tenant's own; the brand's memory, read by the merge and by every builder"
section: concepts
address: /concepts/branddecision
contract: 0476e35e6e275db5
---

# BrandDecision

a tenant's decision on one value of the brand's design system: accepted, declined, or changed to the tenant's own; the brand's memory, read by the merge and by every builder

[figure: BrandDecision is a fact at brand scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | brand |
| key | the brand, the path and the time |
| store | postgres |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `brand` | `id` | yes |  |
| `path` | `text` | yes | the value's path in the system |
| `proposed` | `json` | no | the value proposed at the time |
| `decision` | `one of accepted \| declined \| changed` | yes |  |
| `value` | `json` | no | the tenant's own value when changed |
| `why` | `text` | no |  |
| `version` | `count` | yes | the version of the system the decision was made on |



## Routes that use it
- [`/v1/act/decide_brand_design`](/reference/act/decide_brand_design) returns it


---
title: "BrandDelta"
description: "one value a variant changes over its parent, by its path"
section: concepts
address: /concepts/branddelta
contract: 0476e35e6e275db5
---

# BrandDelta

one value a variant changes over its parent, by its path

[figure: BrandDelta is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `path` | `text` | yes | the value's path in the system: colours.surface.light, spacing.unit, type_scale.3.px |
| `value` | `json` | yes |  |
| `basis` | [Basis](/concepts/basis) | yes | measured where the site declares it, derived by the named rule otherwise |
| `from` | `[hash]` | yes |  |



## Routes that use it
No route takes or returns BrandDelta directly. The record holds it, and the objects that point at it reach it.


---
title: "BrandDesignSystem"
description: "the brand's visual system made from its pages held whole: every value with its basis and the artefacts it was read from, and the same values in the platform's token shape"
section: concepts
address: /concepts/branddesignsystem
contract: 0476e35e6e275db5
---

# BrandDesignSystem

the brand's visual system made from its pages held whole: every value with its basis and the artefacts it was read from, and the same values in the platform's token shape

[figure: BrandDesignSystem is a definition at brand scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | brand |
| key | the brand and its version |
| store | postgres |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `brand` | `id` | yes |  |
| `website` | `address` | yes | the site the pages were captured from |
| `pages_read` | `[hash]` | yes | the captures whose documents were read whole |
| `site_tokens` | [BrandSiteToken](/concepts/brandsitetoken) | yes | the custom properties the site declares on its root |
| `colours` | [BrandColour](/concepts/brandcolour) | yes | every colour declared, with its count, and the roles |
| `modes` | `[text]` | yes | the colour modes measured: light, and dark where the site declares one |
| `faces` | [BrandFace](/concepts/brandface) | yes | the body, heading and fixed-width faces |
| `type_scale` | [BrandTypeStep](/concepts/brandtypestep) | yes |  |
| `scale_ratio` | [BrandRatio](/concepts/brandratio) | no | the ratio between consecutive sizes when the scale is modular, inferred by the named rule |
| `hierarchy` | [BrandHierarchyLevel](/concepts/brandhierarchylevel) | yes | the visual hierarchy and what makes it up: each level's size, line, weight, colour and the space below it, from the rules on the heading elements, the body and the small text |
| `spacing` | [BrandStep](/concepts/brandstep) | yes |  |
| `spacing_unit` | [BrandStep](/concepts/brandstep) | no | inferred by the named rule from the most used steps |
| `rhythm` | [BrandRhythm](/concepts/brandrhythm) | no | the vertical rhythm: the baseline and the share of vertical steps on it, inferred by the named rule |
| `radii` | [BrandStep](/concepts/brandstep) | yes |  |
| `borders` | [BrandBorder](/concepts/brandborder) | yes | every border width and style declared |
| `shadows` | [BrandShadow](/concepts/brandshadow) | yes |  |
| `gradients` | [BrandGradient](/concepts/brandgradient) | yes | every gradient declared, with its colours |
| `durations` | [BrandDuration](/concepts/brandduration) | yes | every transition and animation duration declared |
| `easings` | [BrandEasing](/concepts/brandeasing) | yes | every timing function declared |
| `keyframes` | [BrandKeyframes](/concepts/brandkeyframes) | yes | every keyframes block declared: the site's own animations |
| `breakpoints` | [BrandBreakpoint](/concepts/brandbreakpoint) | yes | every width the media queries turn on |
| `z_layers` | [BrandLayer](/concepts/brandlayer) | yes | every z-index declared: the site's stacking layers |
| `grid` | [BrandGrid](/concepts/brandgrid) | no | the layout grid: container widths, column counts and gutters |
| `icons` | [BrandIconography](/concepts/brandiconography) | no | the icon system the pages use and the sizes drawn |
| `components` | [BrandComponent](/concepts/brandcomponent) | yes | the recurring parts of the pages: a class the stylesheet styles as a surface, used on the pages, with its declarations |
| `elements` | [BrandElement](/concepts/brandelement) | yes | the brand's elements by kind: logo, icon, mark, texture, illustration, imagery, photo, shape; the held file of each where one is held |
| `assets` | [BrandAsset](/concepts/brandasset) | yes | every file the pages load that is held: images, animated images, icons, fonts and media, each by its bytes |
| `traits` | [BrandTrait](/concepts/brandtrait) | yes | the motifs read from the measured values by named rules: the palette's shape, the corners, the depth, the type, the grid, the buttons, the cards, the fields, the badges, the iconography; imagery and composition come from the rendered pass |
| `frameworks` | `[text]` | yes | the style frameworks the pages show signs of (Tailwind, Bootstrap), measured from the class names and the compiled stylesheet |
| `variants` | [BrandVariant](/concepts/brandvariant) | yes | the base and every variant: the dark mode measured or derived, the densities, the high contrast, and the media, each a sparse delta over its parent with its derivation and its rules; the resolver reads the effective system at any coordinate |
| `templates` | [BrandTemplate](/concepts/brandtemplate) | yes | the templates of every format on the base variant, derived by rule: the frames, their scaffolds and their CSS |
| `logo` | [BrandLogo](/concepts/brandlogo) | no |  |
| `gaps` | [CoverageGap](/concepts/coveragegap) | yes | what was not measured and what would measure it |
| `platform_tokens` | `json` | yes | the measured values in the DesignSystem row's token shape, generated from the typed values and nowhere else |
| `exports` | [BrandExports](/concepts/brandexports) | yes | the same values as CSS custom properties, a Tailwind theme extension, Figma variables with modes and a design-tokens (DTCG) file, generated from the typed values and nowhere else |



## Routes that use it
- [`/v1/read/brand_design_system`](/reference/read/brand_design_system) returns it
- [`/v1/act/make_brand_design_system`](/reference/act/make_brand_design_system) returns it


---
title: "BrandDesignSystemChangesInput"
description: "the brand and two versions, else the two newest"
section: concepts
address: /concepts/branddesignsystemchangesinput
contract: 0476e35e6e275db5
---

# BrandDesignSystemChangesInput

the brand and two versions, else the two newest

[figure: BrandDesignSystemChangesInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `brand` | `id` | yes |  |
| `from_version` | `count` | no |  |
| `to_version` | `count` | no |  |



## Routes that use it
- [`/v1/read/brand_design_system_changes`](/reference/read/brand_design_system_changes) takes it as input


---
title: "BrandDesignSystemDiff"
description: "what changed between two versions of a brand's design system"
section: concepts
address: /concepts/branddesignsystemdiff
contract: 0476e35e6e275db5
---

# BrandDesignSystemDiff

what changed between two versions of a brand's design system

[figure: BrandDesignSystemDiff is a view at brand scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | brand |
| key | the brand and the two versions |
| store | derived |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `brand` | `id` | yes |  |
| `from_version` | `count` | yes |  |
| `to_version` | `count` | yes |  |
| `changes` | [BrandChange](/concepts/brandchange) | yes |  |
| `added` | `count` | yes |  |
| `removed` | `count` | yes |  |
| `changed` | `count` | yes |  |



## Routes that use it
- [`/v1/read/brand_design_system_changes`](/reference/read/brand_design_system_changes) returns it


---
title: "BrandDesignSystemInput"
description: "the brand, and the version wanted, else the newest"
section: concepts
address: /concepts/branddesignsysteminput
contract: 0476e35e6e275db5
---

# BrandDesignSystemInput

the brand, and the version wanted, else the newest

[figure: BrandDesignSystemInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `brand` | `id` | yes |  |
| `version` | `count` | no |  |



## Routes that use it
- [`/v1/read/brand_design_system`](/reference/read/brand_design_system) takes it as input


---
title: "BrandDuration"
description: "one duration of motion a site declares"
section: concepts
address: /concepts/brandduration
contract: 0476e35e6e275db5
---

# BrandDuration

one duration of motion a site declares

[figure: BrandDuration is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `ms` | `number` | yes |  |
| `uses` | `count` | yes |  |
| `properties` | `[text]` | yes | transition or animation |
| `basis` | [Basis](/concepts/basis) | yes |  |
| `from` | `[hash]` | yes |  |



## Routes that use it
No route takes or returns BrandDuration directly. The record holds it, and the objects that point at it reach it.


---
title: "BrandEasing"
description: "one timing function a site declares"
section: concepts
address: /concepts/brandeasing
contract: 0476e35e6e275db5
---

# BrandEasing

one timing function a site declares

[figure: BrandEasing is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `value` | `text` | yes | ease, linear, a cubic-bezier or steps, as declared |
| `uses` | `count` | yes |  |
| `basis` | [Basis](/concepts/basis) | yes |  |
| `from` | `[hash]` | yes |  |



## Routes that use it
No route takes or returns BrandEasing directly. The record holds it, and the objects that point at it reach it.


---
title: "BrandElement"
description: "one element of the brand by kind, the old layer's element kinds kept"
section: concepts
address: /concepts/brandelement
contract: 0476e35e6e275db5
---

# BrandElement

one element of the brand by kind, the old layer's element kinds kept

[figure: BrandElement is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `kind` | `one of logo \| icon \| mark \| texture \| illustration \| imagery \| photo \| shape` | yes |  |
| `address` | `address` | no |  |
| `artefact` | `hash` | no | the held file |
| `basis` | [Basis](/concepts/basis) | yes |  |
| `from` | `[hash]` | yes |  |



## Routes that use it
No route takes or returns BrandElement directly. The record holds it, and the objects that point at it reach it.


---
title: "BrandExports"
description: "the design system in the shapes the tools outside the platform read, each generated from the typed values"
section: concepts
address: /concepts/brandexports
contract: 0476e35e6e275db5
---

# BrandExports

the design system in the shapes the tools outside the platform read, each generated from the typed values

[figure: BrandExports is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `css` | `text` | yes | custom properties, light on :root and dark under [data-theme=dark] |
| `tailwind` | `json` | yes | a theme.extend block |
| `figma` | `json` | yes | variable collections with light and dark modes |
| `dtcg` | `json` | yes | a design tokens file, each token with its basis and its artefacts as extensions |
| `brief` | `text` | yes | the constraint block a generation prompt or a document build reads: the values, the traits and the do and do-not lines, in plain sentences |



## Routes that use it
No route takes or returns BrandExports directly. The record holds it, and the objects that point at it reach it.


---
title: "BrandFace"
description: "one type face of a brand's site by its role"
section: concepts
address: /concepts/brandface
contract: 0476e35e6e275db5
---

# BrandFace

one type face of a brand's site by its role

[figure: BrandFace is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `role` | `one of body \| heading \| mono` | yes |  |
| `family` | `text` | yes | the font-family value as declared |
| `weights` | `[count]` | yes | the weights declared for it |
| `basis` | [Basis](/concepts/basis) | yes |  |
| `from` | `[hash]` | yes |  |



## Routes that use it
No route takes or returns BrandFace directly. The record holds it, and the objects that point at it reach it.


---
title: "BrandFrame"
description: "one frame of a template: its role, its layout, the scaffold a build reads, the values and elements it uses"
section: concepts
address: /concepts/brandframe
contract: 0476e35e6e275db5
---

# BrandFrame

one frame of a template: its role, its layout, the scaffold a build reads, the values and elements it uses

[figure: BrandFrame is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `role` | `text` | yes | cover, section, content, closing, header, body, footer, title, caption, post, story |
| `layout` | `text` | yes |  |
| `scaffold` | `text` | yes | what the frame holds, in plain sentences, for a build or a generation prompt |
| `token_paths` | `[text]` | yes | the values it uses, by path |
| `element_kinds` | `[text]` | yes | the element kinds it places |
| `basis` | [Basis](/concepts/basis) | yes |  |
| `from` | `[hash]` | yes |  |



## Routes that use it
No route takes or returns BrandFrame directly. The record holds it, and the objects that point at it reach it.


---
title: "BrandGradient"
description: "one gradient a site declares, with the colours read out of it"
section: concepts
address: /concepts/brandgradient
contract: 0476e35e6e275db5
---

# BrandGradient

one gradient a site declares, with the colours read out of it

[figure: BrandGradient is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `value` | `text` | yes | the gradient as declared, with the site's variables resolved |
| `colours` | `[text]` | yes |  |
| `uses` | `count` | yes |  |
| `basis` | [Basis](/concepts/basis) | yes |  |
| `from` | `[hash]` | yes |  |



## Routes that use it
No route takes or returns BrandGradient directly. The record holds it, and the objects that point at it reach it.


---
title: "BrandGrid"
description: "the layout grid of the pages"
section: concepts
address: /concepts/brandgrid
contract: 0476e35e6e275db5
---

# BrandGrid

the layout grid of the pages

[figure: BrandGrid is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `containers` | `[number]` | yes | the max-widths declared on containers, in px |
| `columns` | `[count]` | yes | the column counts of the grids declared |
| `gutter` | `number` | no | the most used grid gap, in px |
| `basis` | [Basis](/concepts/basis) | yes |  |
| `from` | `[hash]` | yes |  |



## Routes that use it
No route takes or returns BrandGrid directly. The record holds it, and the objects that point at it reach it.


---
title: "BrandHierarchyLevel"
description: "one level of the visual hierarchy and what makes it up"
section: concepts
address: /concepts/brandhierarchylevel
contract: 0476e35e6e275db5
---

# BrandHierarchyLevel

one level of the visual hierarchy and what makes it up

[figure: BrandHierarchyLevel is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `one of h1 \| h2 \| h3 \| h4 \| h5 \| h6 \| body \| small \| label` | yes |  |
| `px` | `number` | yes |  |
| `line` | `number` | no |  |
| `weight` | `count` | no |  |
| `colour` | `text` | no |  |
| `space_below` | `number` | no | the margin below it, in px |
| `uses` | `count` | yes | the elements on the pages held |
| `basis` | [Basis](/concepts/basis) | yes |  |
| `from` | `[hash]` | yes |  |



## Routes that use it
No route takes or returns BrandHierarchyLevel directly. The record holds it, and the objects that point at it reach it.


---
title: "BrandIconography"
description: "the icon system the pages use"
section: concepts
address: /concepts/brandiconography
contract: 0476e35e6e275db5
---

# BrandIconography

the icon system the pages use

[figure: BrandIconography is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `system` | `one of inline svg \| svg sprite \| icon font \| image files \| none` | yes |  |
| `count` | `count` | yes | the icons drawn on the pages held |
| `sizes` | `[number]` | yes | the sizes drawn, in px |
| `basis` | [Basis](/concepts/basis) | yes |  |
| `from` | `[hash]` | yes |  |



## Routes that use it
No route takes or returns BrandIconography directly. The record holds it, and the objects that point at it reach it.


---
title: "BrandKeyframes"
description: "one keyframes block a site declares: an animation of its own"
section: concepts
address: /concepts/brandkeyframes
contract: 0476e35e6e275db5
---

# BrandKeyframes

one keyframes block a site declares: an animation of its own

[figure: BrandKeyframes is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `steps` | `count` | yes | the keyframe selectors in the block |
| `properties` | `[text]` | yes | the properties the animation moves |
| `basis` | [Basis](/concepts/basis) | yes |  |
| `from` | `[hash]` | yes |  |



## Routes that use it
No route takes or returns BrandKeyframes directly. The record holds it, and the objects that point at it reach it.


---
title: "BrandLayer"
description: "one stacking layer: a z-index declared and what sits on it"
section: concepts
address: /concepts/brandlayer
contract: 0476e35e6e275db5
---

# BrandLayer

one stacking layer: a z-index declared and what sits on it

[figure: BrandLayer is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `value` | `number` | yes |  |
| `uses` | `count` | yes |  |
| `selectors` | `[text]` | yes |  |
| `basis` | [Basis](/concepts/basis) | yes |  |
| `from` | `[hash]` | yes |  |



## Routes that use it
No route takes or returns BrandLayer directly. The record holds it, and the objects that point at it reach it.


---
title: "BrandLogo"
description: "the brand's logo: its address on the site and its file when the file is held"
section: concepts
address: /concepts/brandlogo
contract: 0476e35e6e275db5
---

# BrandLogo

the brand's logo: its address on the site and its file when the file is held

[figure: BrandLogo is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `address` | `address` | yes |  |
| `artefact` | `hash` | no | the file's hash in bronze; absent when the file is not held |
| `kind` | `text` | no | svg, png, jpeg, webp, gif or ico, read from the bytes |
| `found_by` | `text` | yes | the rule that chose it |
| `basis` | [Basis](/concepts/basis) | yes |  |
| `from` | `[hash]` | yes |  |



## Routes that use it
No route takes or returns BrandLogo directly. The record holds it, and the objects that point at it reach it.


---
title: "BrandRatio"
description: "the ratio of a modular type scale, with the name the field gives it"
section: concepts
address: /concepts/brandratio
contract: 0476e35e6e275db5
---

# BrandRatio

the ratio of a modular type scale, with the name the field gives it

[figure: BrandRatio is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `ratio` | `number` | yes |  |
| `name` | `text` | yes | minor second, major second, minor third, major third, perfect fourth, augmented fourth, perfect fifth, golden, or the ratio itself |
| `basis` | [Basis](/concepts/basis) | yes |  |
| `from` | `[hash]` | yes |  |



## Routes that use it
No route takes or returns BrandRatio directly. The record holds it, and the objects that point at it reach it.


---
title: "BrandRhythm"
description: "the vertical rhythm of the pages"
section: concepts
address: /concepts/brandrhythm
contract: 0476e35e6e275db5
---

# BrandRhythm

the vertical rhythm of the pages

[figure: BrandRhythm is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `baseline_px` | `number` | yes | the line height of the body, else the most used line height |
| `on_baseline` | `share` | yes | the share of vertical spacing steps and line heights that are multiples of the baseline |
| `basis` | [Basis](/concepts/basis) | yes |  |
| `from` | `[hash]` | yes |  |



## Routes that use it
No route takes or returns BrandRhythm directly. The record holds it, and the objects that point at it reach it.


---
title: "BrandShadow"
description: "one shadow value"
section: concepts
address: /concepts/brandshadow
contract: 0476e35e6e275db5
---

# BrandShadow

one shadow value

[figure: BrandShadow is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `value` | `text` | yes | the box-shadow value as declared |
| `uses` | `count` | yes |  |
| `basis` | [Basis](/concepts/basis) | yes |  |
| `from` | `[hash]` | yes |  |



## Routes that use it
No route takes or returns BrandShadow directly. The record holds it, and the objects that point at it reach it.


---
title: "BrandSiteToken"
description: "one custom property a site declares on its root"
section: concepts
address: /concepts/brandsitetoken
contract: 0476e35e6e275db5
---

# BrandSiteToken

one custom property a site declares on its root

[figure: BrandSiteToken is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `value` | `text` | yes |  |
| `basis` | [Basis](/concepts/basis) | yes |  |
| `from` | `[hash]` | yes |  |



## Routes that use it
No route takes or returns BrandSiteToken directly. The record holds it, and the objects that point at it reach it.


---
title: "BrandStep"
description: "one step of spacing or one radius"
section: concepts
address: /concepts/brandstep
contract: 0476e35e6e275db5
---

# BrandStep

one step of spacing or one radius

[figure: BrandStep is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `px` | `number` | yes |  |
| `uses` | `count` | yes |  |
| `basis` | [Basis](/concepts/basis) | yes |  |
| `from` | `[hash]` | yes |  |



## Routes that use it
No route takes or returns BrandStep directly. The record holds it, and the objects that point at it reach it.


---
title: "BrandTemplate"
description: "a template of one format on one variant: the frames, their CSS from the resolved values, the motifs and elements it carries; derived by rule, and versioned with the system"
section: concepts
address: /concepts/brandtemplate
contract: 0476e35e6e275db5
---

# BrandTemplate

a template of one format on one variant: the frames, their CSS from the resolved values, the motifs and elements it carries; derived by rule, and versioned with the system

[figure: BrandTemplate is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `format` | `one of page \| deck \| infographic \| storyboard \| social \| diagram \| figure \| video` | yes |  |
| `variant` | `text` | yes | the variant it stands on |
| `frames` | [BrandFrame](/concepts/brandframe) | yes |  |
| `css` | `text` | yes | the frames' rules from the resolved values |
| `motif_names` | `[text]` | yes | the traits it expresses |
| `basis` | [Basis](/concepts/basis) | yes |  |
| `from` | `[hash]` | yes |  |



## Routes that use it
No route takes or returns BrandTemplate directly. The record holds it, and the objects that point at it reach it.


---
title: "BrandTrait"
description: "one motif of the brand, read from the measured values by a named rule"
section: concepts
address: /concepts/brandtrait
contract: 0476e35e6e275db5
---

# BrandTrait

one motif of the brand, read from the measured values by a named rule

[figure: BrandTrait is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes | palette, corners, depth, type, grid, buttons, cards, fields, badges, iconography, imagery or composition |
| `value` | `text` | yes |  |
| `evidence` | `text` | yes | the measured values the rule read |
| `basis` | [Basis](/concepts/basis) | yes |  |
| `from` | `[hash]` | yes |  |



## Routes that use it
No route takes or returns BrandTrait directly. The record holds it, and the objects that point at it reach it.


---
title: "BrandTypeStep"
description: "one size of a brand's type scale"
section: concepts
address: /concepts/brandtypestep
contract: 0476e35e6e275db5
---

# BrandTypeStep

one size of a brand's type scale

[figure: BrandTypeStep is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `px` | `number` | yes | resolved at the site's root size |
| `line` | `number` | no | the line height declared beside it, in px |
| `weight` | `count` | no |  |
| `uses` | `count` | yes |  |
| `basis` | [Basis](/concepts/basis) | yes |  |
| `from` | `[hash]` | yes |  |



## Routes that use it
No route takes or returns BrandTypeStep directly. The record holds it, and the objects that point at it reach it.


---
title: "BrandVariant"
description: "the system at one coordinate: a sparse delta over its parent, made by one derivation; the old layer's variants, axes and derivations kept and made rows"
section: concepts
address: /concepts/brandvariant
contract: 0476e35e6e275db5
---

# BrandVariant

the system at one coordinate: a sparse delta over its parent, made by one derivation; the old layer's variants, axes and derivations kept and made rows

[figure: BrandVariant is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `coordinate` | [BrandCoordinate](/concepts/brandcoordinate) | yes |  |
| `parent` | `text` | no | the variant the delta applies over; absent for the base |
| `derivation` | `one of measured \| dark mode \| accent shift \| density \| contrast fix \| modality treatment \| medium` | yes |  |
| `delta` | [BrandDelta](/concepts/branddelta) | yes |  |
| `rules` | `[text]` | yes | the rules of the derivation, each named |
| `basis` | [Basis](/concepts/basis) | yes |  |
| `from` | `[hash]` | yes |  |



## Routes that use it
No route takes or returns BrandVariant directly. The record holds it, and the objects that point at it reach it.


---
title: "BronzeObject"
description: "an artefact as the source gave it, keyed by its content hash, with the way it came by, the job, the time and the hop stamp; the bytes sit beside the row in the engine's own column, never in the row"
section: concepts
address: /concepts/bronzeobject
contract: 0476e35e6e275db5
---

# BronzeObject

an artefact as the source gave it, keyed by its content hash, with the way it came by, the job, the time and the hop stamp; the bytes sit beside the row in the engine's own column, never in the row

[figure: BronzeObject is a fact at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | follows |
| key | its content hash on its plane |
| store | lake:landed |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `hash` | `hash` | yes | the artefact's content hash, its key |
| `source` | [Source](/concepts/source) | yes |  |
| `way` | [AccessMethod](/concepts/accessmethod) | no |  |
| `job` | `id` | yes | the job or the capture that deposited it |
| `address` | `text` | no | the address the artefact was read from, when it has one |
| `kind` | `one of a page \| a file \| a response \| a stream` | yes |  |
| `at` | `time` | yes | when it was deposited |
| `bytes` | `bytes` | yes | the size of the artefact |
| `chunks` | `count` | yes | how many chunks the bytes were written in |
| `hop` | [HopStamp](/concepts/hopstamp) | yes | the deposit's hop |
| `plane` | [Plane](/concepts/plane) | yes |  |



## Routes that use it
No route takes or returns BronzeObject directly. The record holds it, and the objects that point at it reach it.


---
title: "BrowseOpenInput"
description: "open a browsing session under the caller's grant, with a held identity, a proxy policy and a filter"
section: concepts
address: /concepts/browseopeninput
contract: 0476e35e6e275db5
---

# BrowseOpenInput

open a browsing session under the caller's grant, with a held identity, a proxy policy and a filter

[figure: BrowseOpenInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `strategy` | `id` | no |  |
| `identity` | `id` | no |  |
| `proxy_policy` | [ProxyPolicy](/concepts/proxypolicy) | no |  |
| `filter` | [ResourceFilter](/concepts/resourcefilter) | no |  |
| `live_view` | `bool` | yes |  |



## Routes that use it
- [`/v1/work/browse_open`](/reference/work/browse_open) takes it as input


---
title: "BrowseStepInput"
description: "one step in an open browsing session"
section: concepts
address: /concepts/browsestepinput
contract: 0476e35e6e275db5
---

# BrowseStepInput

one step in an open browsing session

[figure: BrowseStepInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `session` | `id` | yes |  |
| `step` | [BrowsingStep](/concepts/browsingstep) | yes |  |



## Routes that use it
- [`/v1/act/browse_step`](/reference/act/browse_step) takes it as input


---
title: "BrowseTakeOverInput"
description: "a person takes the wheel of a session, or hands it back"
section: concepts
address: /concepts/browsetakeoverinput
contract: 0476e35e6e275db5
---

# BrowseTakeOverInput

a person takes the wheel of a session, or hands it back

[figure: BrowseTakeOverInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `session` | `id` | yes |  |
| `hand_back` | `bool` | yes |  |



## Routes that use it
- [`/v1/work/browse_take_over`](/reference/work/browse_take_over) takes it as input


---
title: "BrowseView"
description: "one frame of a browsing session's page as the person sees it, with the page's size and address, read by a dashboard that shows the session live and forwards the person's clicks and words as steps; never a raw browser over the network"
section: concepts
address: /concepts/browseview
contract: 0476e35e6e275db5
---

# BrowseView

one frame of a browsing session's page as the person sees it, with the page's size and address, read by a dashboard that shows the session live and forwards the person's clicks and words as steps; never a raw browser over the network

[figure: BrowseView is a view at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | none |
| key | the session and the time taken |
| store | none |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `session` | `id` | yes |  |
| `address` | `text` | no | the page's address now |
| `width` | `count` | yes | the viewport's width in pixels |
| `height` | `count` | yes |  |
| `frame` | `text` | yes | one JPEG frame of the viewport, base64 |
| `taken_at` | `time` | yes |  |



## Routes that use it
- [`/v1/read/browse_view`](/reference/read/browse_view) returns it


---
title: "BrowseViewInput"
description: "a browsing session whose live view is read"
section: concepts
address: /concepts/browseviewinput
contract: 0476e35e6e275db5
---

# BrowseViewInput

a browsing session whose live view is read

[figure: BrowseViewInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `session` | `id` | yes |  |



## Routes that use it
- [`/v1/read/browse_view`](/reference/read/browse_view) takes it as input


---
title: "BrowsingSession"
description: "a browser of the pool the agent or a person drives step by step through the controlled API, with a live view; never a raw browser over the network"
section: concepts
address: /concepts/browsingsession
contract: 0476e35e6e275db5
---

# BrowsingSession

a browser of the pool the agent or a person drives step by step through the controlled API, with a live view; never a raw browser over the network

[figure: BrowsingSession is a work at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | work |
| scope | follows |
| key | the caller, the strategy and the time opened |
| store | postgres |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `session` | `id` | no | the session's own id, which every later step, view and take-over names; absent on a row written before it was carried |
| `caller` | [Caller](/concepts/caller) | yes | our agent under its own role and scope, or a person |
| `strategy` | `id` | no |  |
| `identity` | `id` | no | a held identity, lent by a grant |
| `proxy_policy` | [ProxyPolicy](/concepts/proxypolicy) | no |  |
| `filter` | [ResourceFilter](/concepts/resourcefilter) | yes |  |
| `mode` | `one of read only \| propose \| act \| full autonomy` | yes | the grant's mode |
| `steps` | [BrowsingStep](/concepts/browsingstep) | yes |  |
| `live_view` | `bool` | yes | the screencast on the app server's wire |
| `taken_over_by` | `id` | no | a person who took the wheel |



## Routes that use it
- [`/v1/work/browse_open`](/reference/work/browse_open) returns it
- [`/v1/work/browse_take_over`](/reference/work/browse_take_over) returns it


---
title: "BrowsingStep"
description: "one step in a browser, the agent's in a browsing session or the person's own as the extension saw it under a capture rule: navigate, read, click, type, select, submit, scroll, wait, screenshot, download, close; a step that submits or sends is an action with a reach"
section: concepts
address: /concepts/browsingstep
contract: 0476e35e6e275db5
---

# BrowsingStep

one step in a browser, the agent's in a browsing session or the person's own as the extension saw it under a capture rule: navigate, read, click, type, select, submit, scroll, wait, screenshot, download, close; a step that submits or sends is an action with a reach

[figure: BrowsingStep is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `kind` | `one of navigate \| read \| click \| type \| press \| select \| submit \| scroll \| wait \| screenshot \| download \| close` | yes | a press step presses one key, named in the value by its standard key name (Backspace, Delete, Tab, Enter, Escape, ArrowLeft, ArrowRight, ArrowUp, ArrowDown, Home, End, PageUp, PageDown, Space) |
| `target` | `text` | no | an address, a selector, an accessibility node, or a point on the page as x,y for a click; a type or press step with no target acts on the field that has focus |
| `value` | `text` | no |  |
| `reading` | `one of none \| the address and the title \| the whole page` | no | what the step reads of the page after it acts; absent means the whole page for navigate, read, scroll and wait, and the address and the title for click, type, press, select and submit |
| `reach` | `one of reads only \| writes to the tenant's own system \| speaks as the brand \| spends money outside \| sends to a person` | yes | reads only unless the step submits or sends |
| `result` | `json` | no | the accessibility tree, the text, the markdown, the screenshot's hash |
| `hop` | [HopStamp](/concepts/hopstamp) | yes |  |



## Routes that use it
- [`/v1/act/browse_step`](/reference/act/browse_step) returns it


---
title: "BucketCounts"
description: "the value of the parameter the layout of a table keyed by an entity: the count of buckets each plane splits it into"
section: concepts
address: /concepts/bucketcounts
contract: 0476e35e6e275db5
---

# BucketCounts

the value of the parameter the layout of a table keyed by an entity: the count of buckets each plane splits it into

[figure: BucketCounts is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | record |



## Fields


| field | type | required | note |
|---|---|---|---|
| `shared` | `count` | yes |  |
| `tenant` | `count` | yes |  |
| `platform` | `count` | yes |  |



## Routes that use it
No route takes or returns BucketCounts directly. The record holds it, and the objects that point at it reach it.


---
title: "Budget"
description: "a strategy's budget by kind, of the receive family; reading the public market is never in it"
section: concepts
address: /concepts/budget
contract: 0476e35e6e275db5
---

# Budget

a strategy's budget by kind, of the receive family; reading the public market is never in it

[figure: Budget is a parameter at strategy scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | parameter |
| scope | strategy |
| key | the strategy |
| store | postgres |
| family | strategy |



## Fields


| field | type | required | note |
|---|---|---|---|
| `money_outside` | `money` | yes |  |
| `model_calls` | `count` | yes |  |
| `workbench_time` | `duration` | yes |  |
| `people_hours` | `duration` | yes |  |
| `spent` | [Cost](/concepts/cost) | yes |  |
| `window` | [Window](/concepts/window) | yes |  |



## Routes that use it
No route takes or returns Budget directly. The record holds it, and the objects that point at it reach it.


---
title: "BudgetForecast"
description: "the spend a buyer can put to this kind of purchase in one period, month or quarter: an estimate with its interval and its balance of evidence, the inputs it read, and its calibration against what followed"
section: concepts
address: /concepts/budgetforecast
contract: 0476e35e6e275db5
---

# BudgetForecast

the spend a buyer can put to this kind of purchase in one period, month or quarter: an estimate with its interval and its balance of evidence, the inputs it read, and its calibration against what followed

[figure: BudgetForecast is a fact at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | follows |
| key | the buyer and the period |
| store | postgres+lake |
| family | models |



## Fields


| field | type | required | note |
|---|---|---|---|
| `buyer` | `id` | yes |  |
| `period` | `text` | yes | a month or a quarter, such as 2026-10 or 2026-Q4 |
| `estimate` | [Estimate](/concepts/estimate) | yes | never a point without its interval |
| `inputs` | [EvidenceRef](/concepts/evidenceref) | yes | the means proxy, the firmographic facts, the constraints and the market numbers read |
| `calibration` | [Calibration](/concepts/calibration) | no | against the outcomes, once they exist |
| `as_of` | [TwoDates](/concepts/twodates) | yes |  |



## Routes that use it
No route takes or returns BudgetForecast directly. The record holds it, and the objects that point at it reach it.


---
title: "Build"
description: "one build of a document, every number naming the unit that supplied it"
section: concepts
address: /concepts/build
contract: 0476e35e6e275db5
---

# Build

one build of a document, every number naming the unit that supplied it

[figure: Build is a work at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | work |
| scope | follows |
| key | the document and the two dates |
| store | postgres |
| family | documents |



## Fields


| field | type | required | note |
|---|---|---|---|
| `document` | `id` | yes |  |
| `as_of` | [TwoDates](/concepts/twodates) | yes |  |
| `made_from` | `[id]` | yes |  |
| `numbers` | [ChippedNumber](/concepts/chippednumber) | yes |  |
| `figures` | `[id]` | yes |  |
| `check` | [ControlResult](/concepts/controlresult) | yes |  |
| `missing` | `[text]` | yes | for not ready |



## Routes that use it
- [`/v1/read/document`](/reference/read/document) returns it
- [`/v1/act/build_document`](/reference/act/build_document) returns it


---
title: "BuildDocumentInput"
description: "a document, as of two dates"
section: concepts
address: /concepts/builddocumentinput
contract: 0476e35e6e275db5
---

# BuildDocumentInput

a document, as of two dates

[figure: BuildDocumentInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `document` | `id` | yes |  |



## Routes that use it
- [`/v1/act/build_document`](/reference/act/build_document) takes it as input


---
title: "BuildFacetInput"
description: "a facet to build from a seed"
section: concepts
address: /concepts/buildfacetinput
contract: 0476e35e6e275db5
---

# BuildFacetInput

a facet to build from a seed

[figure: BuildFacetInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `facet_kind` | [FacetKind](/concepts/facetkind) | yes |  |
| `seed` | `text` | yes |  |
| `again` | `bool` | no | when true, the same seed is built again as new work, for a presence that changed since the last build; without it the same seed under the same measure is the same work and returns the run already made |
| `asked_again_at` | `time` | no | set by the tool from the ask, so the run's key differs; never typed by hand |
| `scope` | [Scope](/concepts/scope) | yes |  |



## Routes that use it
- [`/v1/work/build_facet`](/reference/work/build_facet) takes it as input


---
title: "BuildState"
description: "every build stage, its acceptance procedure, and when it last showed red and then green"
section: concepts
address: /concepts/buildstate
contract: 0476e35e6e275db5
---

# BuildState

every build stage, its acceptance procedure, and when it last showed red and then green

[figure: BuildState is a view at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | platform |
| key | the moment |
| store | derived |
| family | ops_console |



## Fields


| field | type | required | note |
|---|---|---|---|
| `stages` | [StageState](/concepts/stagestate) | yes |  |



## Routes that use it
No route takes or returns BuildState directly. The record holds it, and the objects that point at it reach it.


---
title: "BusinessModel"
description: "how one buyer profile earns, and the driver tree that turns that into the return one offering gives it; ready only when the tree reaches its four outputs and every dimension follows"
section: concepts
address: /concepts/businessmodel
contract: 0476e35e6e275db5
---

# BusinessModel

how one buyer profile earns, and the driver tree that turns that into the return one offering gives it; ready only when the tree reaches its four outputs and every dimension follows

[figure: BusinessModel is a definition at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | platform |
| key | its segment or buyer profile, and its version |
| store | postgres |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `vertical` | `id` | yes |  |
| `segment` | `id` | no | the segment of the vertical it describes; absent for a model at the buyer profile's depth |
| `kind_of_buyer` | `id` | no |  |
| `revenue_model` | `text` | yes | how the kind earns, in the field's terms: subscription, retainer, project, per seat, usage, transaction take, margin on goods, reimbursement, donations, management fees |
| `shape` | [CalculationShape](/concepts/calculationshape) | yes | the calculation shape the model instantiates |
| `bindings` | `{text:text}` | yes | the shape's role names bound to this model's drivers, by name |
| `tree` | [DriverNode](/concepts/drivernode) | yes | the shape's tree with the bindings applied: the roots, one per output, each a tree over drivers |
| `outputs` | `[text]` | yes | the four outputs the tree must reach: incremental value, cost, return, payback |
| `assumptions` | [Assumption](/concepts/assumption) | yes | each disclosed on every page and frame that reads the model |
| `version` | `count` | yes |  |
| `content_hash` | `hash` | yes |  |
| `state` | [Readiness](/concepts/readiness) | yes | not ready with the node named when the tree fails its check |
| `original` | `id` | no | the platform's row a brand's copy names |
| `depth` | `one of full \| lighter` | yes | the depth of the research behind the model |
| `adult_rooms` | `one of left out by default \| kept and used` | yes | whether a brand under this model reads the rooms marked adult by default. A vertical that draws real signal from those rooms keeps them, and every other vertical leaves them out unless a call opts in. |
| `note` | `text` | no | how the model was placed when the research's table did not list its profile |



## Routes that use it
No route takes or returns BusinessModel directly. The record holds it, and the objects that point at it reach it.


---
title: "BuyerFitVerdict"
description: "the fit with its criteria, its temperature and its verdict"
section: concepts
address: /concepts/buyerfitverdict
contract: 0476e35e6e275db5
---

# BuyerFitVerdict

the fit with its criteria, its temperature and its verdict

[figure: BuyerFitVerdict is a view at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `entity` | `id` | yes |  |
| `kind_of_buyer` | `id` | yes |  |
| `fit` | [FitScore](/concepts/fitscore) | yes |  |
| `criteria` | [CriterionVerdict](/concepts/criterionverdict) | yes |  |
| `verdict` | `one of a lead \| ready to judge \| not a buyer` | yes |  |
| `temperature` | `one of hot \| warm \| cold` | no |  |
| `temperature_reason` | `text` | no |  |
| `offerings_that_fit` | [OfferingFit](/concepts/offeringfit) | yes |  |



## Routes that use it
- [`/v1/ask/judge_fit`](/reference/ask/judge_fit) returns it


---
title: "BuyingBehaviour"
description: "how one participant buys, as observable stocks and flows: the stage it stands on, how often it buys, what starts a purchase, what constrains it, and the readings that say so"
section: concepts
address: /concepts/buyingbehaviour
contract: 0476e35e6e275db5
---

# BuyingBehaviour

how one participant buys, as observable stocks and flows: the stage it stands on, how often it buys, what starts a purchase, what constrains it, and the readings that say so

[figure: BuyingBehaviour is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `stage` | `text` | yes | the rung of the ladder the participant stands on, in the ladder's words |
| `cadence` | `text` | yes | how often it buys, in the vertical's words |
| `triggers` | `[text]` | yes | what starts a purchase |
| `constraints` | `[text]` | yes | what blocks or delays one |
| `budget_cycle` | `text` | no |  |
| `decision_time` | `duration` | no | from the felt problem to the order, where read |
| `readings` | [Summary](/concepts/summary) | yes | every count behind the words, in one of three positions |
| `evidence` | [EvidenceRef](/concepts/evidenceref) | yes |  |



## Routes that use it
No route takes or returns BuyingBehaviour directly. The record holds it, and the objects that point at it reach it.


---
title: "CacheEntry"
description: "one cached answer"
section: concepts
address: /concepts/cacheentry
contract: 0476e35e6e275db5
---

# CacheEntry

one cached answer

[figure: CacheEntry is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `call` | `text` | yes |  |
| `input_hash` | `hash` | yes |  |
| `as_of` | [TwoDates](/concepts/twodates) | yes |  |
| `expires_at` | `time` | yes |  |
| `expires_on_event` | [Flow](/concepts/flow) | no |  |



## Routes that use it
No route takes or returns CacheEntry directly. The record holds it, and the objects that point at it reach it.


---
title: "CacheInput"
description: "nothing, or a call to forget"
section: concepts
address: /concepts/cacheinput
contract: 0476e35e6e275db5
---

# CacheInput

nothing, or a call to forget

[figure: CacheInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `forget` | `text` | no | the call name and its input hash |



## Routes that use it
- [`/v1/session/cache`](/reference/session/cache) takes it as input


---
title: "CacheView"
description: "what the app holds from earlier answers"
section: concepts
address: /concepts/cacheview
contract: 0476e35e6e275db5
---

# CacheView

what the app holds from earlier answers

[figure: CacheView is a view at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `entries` | [CacheEntry](/concepts/cacheentry) | yes |  |



## Routes that use it
- [`/v1/session/cache`](/reference/session/cache) returns it


---
title: "Cadence"
description: "when the host reads, within politeness; set only by a demand statement"
section: concepts
address: /concepts/cadence
contract: 0476e35e6e275db5
---

# Cadence

when the host reads, within politeness; set only by a demand statement

[figure: Cadence is a definition at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | platform |
| key | the source and the way |
| store | acquisition |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `way` | [AccessMethod](/concepts/accessmethod) | yes |  |
| `every` | `duration` | yes |  |
| `term` | [Window](/concepts/window) | yes |  |
| `state` | [Readiness](/concepts/readiness) | yes |  |



## Routes that use it
No route takes or returns Cadence directly. The record holds it, and the objects that point at it reach it.


---
title: "CalculationShape"
description: "one of the few ways a buyer profile earns value from an offering, as a driver tree over role names that a business model binds to its own drivers: a sales pipeline to a recurring contract; a client won then a retainer over its tenure; a proposal won then a project; a deal then margin on goods; a player or member…"
section: concepts
address: /concepts/calculationshape
contract: 0476e35e6e275db5
---

# CalculationShape

one of the few ways a buyer profile earns value from an offering, as a driver tree over role names that a business model binds to its own drivers: a sales pipeline to a recurring contract; a client won then a retainer over its tenure; a proposal won then a project; a deal then margin on goods; a player or member…

[figure: CalculationShape is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | its letter |
| store | postgres |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `letter` | `text` | yes | A to F today; a new shape is a new row |
| `name` | `text` | yes |  |
| `what` | `text` | yes | how the buyer earns, in one sentence |
| `tree` | [DriverNode](/concepts/drivernode) | yes | the roots over role names, one per output |
| `roles` | `[text]` | yes | the role names a business model binds to its drivers |
| `outputs` | `[text]` | yes | incremental value, cost, return, payback |



## Routes that use it
No route takes or returns CalculationShape directly. The record holds it, and the objects that point at it reach it.


---
title: "Calibration"
description: "precision, recall and the undercount, by segment, with intervals"
section: concepts
address: /concepts/calibration
contract: 0476e35e6e275db5
---

# Calibration

precision, recall and the undercount, by segment, with intervals

[figure: Calibration is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | rules_engine |



## Fields


| field | type | required | note |
|---|---|---|---|
| `precision` | `share` | yes |  |
| `recall` | `share` | yes |  |
| `undercount` | `share` | yes | one minus recall |
| `interval` | [Interval](/concepts/interval) | yes |  |
| `by_segment` | `{text:share}` | yes |  |
| `labelled_set` | `id` | yes |  |
| `read_at` | `time` | yes |  |
| `subjects` | `count` | yes |  |



## Routes that use it
No route takes or returns Calibration directly. The record holds it, and the objects that point at it reach it.


---
title: "CallEnvelope"
description: "what every call carries beside its input: the scope, the two dates for a read, and for a change the key made from the input"
section: concepts
address: /concepts/callenvelope
contract: 0476e35e6e275db5
---

# CallEnvelope

what every call carries beside its input: the scope, the two dates for a read, and for a change the key made from the input

[figure: CallEnvelope is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `scope` | [Scope](/concepts/scope) | yes |  |
| `as_of` | [TwoDates](/concepts/twodates) | no | for a read; both default to now |
| `key` | `text` | no | for a change: made from the input, so a repeat writes nothing |
| `surface` | `one of the interface \| our agent \| an outside agent \| the api` | yes | the surface it calls from |



## Routes that use it
No route takes or returns CallEnvelope directly. The record holds it, and the objects that point at it reach it.


---
title: "Caller"
description: "who is calling, as the auth gateway made it"
section: concepts
address: /concepts/caller
contract: 0476e35e6e275db5
---

# Caller

who is calling, as the auth gateway made it

[figure: Caller is a view at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | none |
| key | made for each request and never stored |
| store | none |
| family | kernel |



## Fields


| field | type | required | note |
|---|---|---|---|
| `kind` | `one of a user \| our agent \| an outside agent \| the platform's own work \| the crawler` | yes |  |
| `acts_for` | `id` | no | the user acted for |
| `came_in_through` | `one of a session \| a key \| a run` | yes |  |
| `client` | `id` | no |  |
| `access_scopes` | [AccessScope](/concepts/accessscope) | yes | on the token |
| `signed_in_strength` | `one of password \| passkey \| second factor` | no |  |
| `signed_in_at` | `time` | no |  |
| `tenant` | `id` | yes | the token is bound to one tenant |
| `grants` | [GrantRef](/concepts/grantref) | yes | after all three narrowings, for the place asked |
| `run` | `id` | no |  |



## Routes that use it
- [`/v1/session/whoami`](/reference/session/whoami) returns it
- [`/v1/session/sign_in`](/reference/session/sign_in) returns it


---
title: "CancelInput"
description: "a preview or a task to cancel"
section: concepts
address: /concepts/cancelinput
contract: 0476e35e6e275db5
---

# CancelInput

a preview or a task to cancel

[figure: CancelInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `task` | `id` | yes |  |



## Routes that use it
- [`/v1/work/cancel`](/reference/work/cancel) takes it as input


---
title: "Candidate"
description: "an entity gathering signals toward the qualifying rung of one kind of buyer"
section: concepts
address: /concepts/candidate
contract: 0476e35e6e275db5
---

# Candidate

an entity gathering signals toward the qualifying rung of one kind of buyer

[figure: Candidate is a work at brand scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | work |
| scope | brand |
| key | the entity, the kind of buyer and the brand |
| store | postgres |
| family | leads |



## Fields


| field | type | required | note |
|---|---|---|---|
| `entity` | `id` | yes |  |
| `kind_of_buyer` | `id` | yes |  |
| `brand` | `id` | yes |  |
| `signals` | `[id]` | yes |  |
| `rung` | `text` | yes | the rung reached |
| `lacks` | `[text]` | yes | what it still lacks |
| `hypothesis` | `id` | no |  |
| `fit` | [FitScore](/concepts/fitscore) | no | the judgement at the qualifying rung, with its interval |
| `criteria` | [CriterionVerdict](/concepts/criterionverdict) | no | each criterion with its probability, its basis and its highlights |



## Routes that use it
No route takes or returns Candidate directly. The record holds it, and the objects that point at it reach it.


---
title: "CandidatesInput"
description: "a brand, and a buyer profile or a place"
section: concepts
address: /concepts/candidatesinput
contract: 0476e35e6e275db5
---

# CandidatesInput

a brand, and a buyer profile or a place

[figure: CandidatesInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `brand` | `id` | yes |  |
| `kind_of_buyer` | `id` | no |  |
| `place` | `text` | no |  |
| `candidate` | `id` | no | one candidate |



## Routes that use it
- [`/v1/read/candidates`](/reference/read/candidates) takes it as input


---
title: "CapabilitiesPage"
description: "the page of capabilities"
section: concepts
address: /concepts/capabilitiespage
contract: 0476e35e6e275db5
---

# CapabilitiesPage

the page of capabilities

[figure: CapabilitiesPage is a view at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `capabilities` | [Capability](/concepts/capability) | yes |  |
| `as_of` | [TwoDates](/concepts/twodates) | yes |  |



## Routes that use it
- [`/v1/view/capabilities`](/reference/view/capabilities) returns it


---
title: "Capability"
description: "a capability the product depends on: where it is on, when it was last proved, and what depends on it"
section: concepts
address: /concepts/capability
contract: 0476e35e6e275db5
---

# Capability

a capability the product depends on: where it is on, when it was last proved, and what depends on it

[figure: Capability is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | its name |
| store | postgres |
| family | ops_console |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `on_where` | [Scope](/concepts/scope) | yes |  |
| `last_proved_at` | `time` | no |  |
| `proved_by` | `text` | no |  |
| `limit` | `duration` | yes | unproved past it shows as not ready |
| `depends_on` | [Capability](/concepts/capability) | yes |  |
| `state` | [Readiness](/concepts/readiness) | yes |  |



## Routes that use it
No route takes or returns Capability directly. The record holds it, and the objects that point at it reach it.


---
title: "Capacity"
description: "how many new leads a user can take in a period, how many they hold, and when it refills"
section: concepts
address: /concepts/capacity
contract: 0476e35e6e275db5
---

# Capacity

how many new leads a user can take in a period, how many they hold, and when it refills

[figure: Capacity is a property at user scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | property |
| scope | user |
| key | the user |
| store | postgres |
| family | leads |



## Fields


| field | type | required | note |
|---|---|---|---|
| `user` | `id` | yes |  |
| `per_period` | `count` | yes |  |
| `period` | `duration` | yes |  |
| `held` | `count` | yes |  |
| `refills_at` | `time` | yes |  |



## Routes that use it
- [`/v1/act/capacity`](/reference/act/capacity) returns it


---
title: "CapacityInput"
description: "a user, how many, and the period"
section: concepts
address: /concepts/capacityinput
contract: 0476e35e6e275db5
---

# CapacityInput

a user, how many, and the period

[figure: CapacityInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `user` | `id` | yes |  |
| `per_period` | `count` | yes |  |
| `period` | `duration` | yes |  |



## Routes that use it
- [`/v1/act/capacity`](/reference/act/capacity) takes it as input


---
title: "Capture"
description: "a page as a person saw it, with the source objects made from it, the neighbourhood the mapping's links define, and the trail"
section: concepts
address: /concepts/capture
contract: 0476e35e6e275db5
---

# Capture

a page as a person saw it, with the source objects made from it, the neighbourhood the mapping's links define, and the trail

[figure: Capture is a fact at tenant scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | tenant |
| key | the artefact's hash, the person and the time |
| store | lake:ready |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `address` | `text` | yes |  |
| `platform` | `text` | yes |  |
| `artefact_hash` | `hash` | yes | the bronze object |
| `captured_by` | `id` | yes |  |
| `identity` | `id` | no | the person's own signed-in identity, never lent |
| `source_objects` | `[id]` | yes |  |
| `neighbourhood` | `[id]` | yes | walked as far as the page shows |
| `cells` | `[id]` | yes | the cells credited |
| `rights` | [Rights](/concepts/rights) | yes | the source role a tenant's own |
| `scope` | `one of this item \| this thread \| this channel as shown \| this page \| this meeting \| my outbound message` | yes |  |
| `under` | `one of say-so \| rule` | yes |  |
| `extension_version` | `text` | yes |  |
| `redactions` | `json` | yes | the count by kind |



## Routes that use it
- [`/v1/act/capture`](/reference/act/capture) returns it


---
title: "CaptureDeclaration"
description: "what the extension keeps on one platform or domain, as one row of the browser connector, parameterized by the platform: address patterns, the network events to keep, the visible links, the scopes and the redactions"
section: concepts
address: /concepts/capturedeclaration
contract: 0476e35e6e275db5
---

# CaptureDeclaration

what the extension keeps on one platform or domain, as one row of the browser connector, parameterized by the platform: address patterns, the network events to keep, the visible links, the scopes and the redactions

[figure: CaptureDeclaration is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | the platform |
| store | postgres |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `platform` | `text` | yes | the platform's slug, or a domain: the parameter of the connector, and the row's key |
| `connector` | [Connector](/concepts/connector) | yes | the browser connector, the same for every row |
| `source` | [Source](/concepts/source) | yes | the registered source the platform's pages land under: the platform as read in the browser, with its own shapes; the same platform read another way is another source |
| `address_patterns` | `[text]` | yes |  |
| `standing_grant` | `bool` | no | the store's review approved a standing host permission for this platform, so the extension's manifest carries it and the browser asks for it at install; absent when the grant is optional and the browser asks for it when a rule for every page needs it (24 §2.1) |
| `network_events` | [ResourceFilter](/concepts/resourcefilter) | yes | the responses to keep |
| `neighbourhood_links` | [MappingConnection](/concepts/mappingconnection) | yes | the links visible on the page |
| `scopes` | `[one of this item \| this thread \| this channel as shown \| this page \| this meeting \| my outbound message]` | yes |  |
| `redactions` | [RedactionRule](/concepts/redactionrule) | yes |  |
| `version` | `text` | yes |  |
| `mark` | `text` | no | the name of the platform's mark in the icon register, or none when no public-domain drawing of it exists |
| `tint` | `text` | no | the platform's own colour for its tile, as its brand states it |



## Routes that use it
No route takes or returns CaptureDeclaration directly. The record holds it, and the objects that point at it reach it.


---
title: "CaptureHealth"
description: "captures by platform, this window against the last"
section: concepts
address: /concepts/capturehealth
contract: 0476e35e6e275db5
---

# CaptureHealth

captures by platform, this window against the last

[figure: CaptureHealth is a view at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `rows` | [CaptureHealthRow](/concepts/capturehealthrow) | yes |  |
| `window` | [Window](/concepts/window) | yes |  |



## Routes that use it
- [`/v1/read/capture_health`](/reference/read/capture_health) returns it


---
title: "CaptureHealthInput"
description: "the health of capture on one platform or all, over a window against the window before"
section: concepts
address: /concepts/capturehealthinput
contract: 0476e35e6e275db5
---

# CaptureHealthInput

the health of capture on one platform or all, over a window against the window before

[figure: CaptureHealthInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `platform` | `text` | no |  |
| `window` | [Window](/concepts/window) | no |  |



## Routes that use it
- [`/v1/read/capture_health`](/reference/read/capture_health) takes it as input


---
title: "CaptureHealthRow"
description: "one platform's captures in the window and the window before, with the verdict"
section: concepts
address: /concepts/capturehealthrow
contract: 0476e35e6e275db5
---

# CaptureHealthRow

one platform's captures in the window and the window before, with the verdict

[figure: CaptureHealthRow is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `platform` | `text` | yes |  |
| `captures` | `count` | yes |  |
| `before` | `count` | yes |  |
| `verdict` | `one of steady \| dropped \| silent \| new` | yes |  |



## Routes that use it
No route takes or returns CaptureHealthRow directly. The record holds it, and the objects that point at it reach it.


---
title: "CaptureInput"
description: "a page the person opened, handed over by the capture extension"
section: concepts
address: /concepts/captureinput
contract: 0476e35e6e275db5
---

# CaptureInput

a page the person opened, handed over by the capture extension

[figure: CaptureInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `address` | `text` | yes |  |
| `document` | `text` | yes |  |
| `network_events` | `[json]` | yes |  |
| `identity` | `id` | no |  |
| `scope` | `one of this item \| this thread \| this channel as shown \| this page \| this meeting \| my outbound message` | yes |  |
| `under` | `one of say-so \| rule` | yes |  |
| `rule` | `id` | no |  |
| `extension_version` | `text` | yes |  |
| `artefact_hash` | `hash` | yes |  |
| `selection` | `text` | no |  |



## Routes that use it
- [`/v1/act/capture`](/reference/act/capture) takes it as input


---
title: "CapturePreview"
description: "what a capture would send: bytes by kind, network events kept and dropped, redactions by kind, the neighbourhood's size, the cells credited and what the plan meters"
section: concepts
address: /concepts/capturepreview
contract: 0476e35e6e275db5
---

# CapturePreview

what a capture would send: bytes by kind, network events kept and dropped, redactions by kind, the neighbourhood's size, the cells credited and what the plan meters

[figure: CapturePreview is a view at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | none |
| key | none |
| store | none |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `scope` | `one of this item \| this thread \| this channel as shown \| this page \| this meeting \| my outbound message` | yes |  |
| `bytes_by_kind` | `json` | yes | document, network events, selection, image |
| `events_kept` | `count` | yes |  |
| `events_dropped` | `count` | yes |  |
| `redactions_by_kind` | `json` | yes |  |
| `items` | `count` | yes |  |
| `people` | `count` | yes |  |
| `cells` | `[id]` | yes |  |
| `metered` | [MeteredUsage](/concepts/meteredusage) | yes | what the plan would count |



## Routes that use it
No route takes or returns CapturePreview directly. The record holds it, and the objects that point at it reach it.


---
title: "CaptureRule"
description: "a person's rule for the capture extension on one platform: on their say-so, every page under a named way, or never"
section: concepts
address: /concepts/capturerule
contract: 0476e35e6e275db5
---

# CaptureRule

a person's rule for the capture extension on one platform: on their say-so, every page under a named way, or never

[figure: CaptureRule is a definition at tenant scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | tenant |
| key | the person and the platform |
| store | postgres |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `person` | `id` | yes |  |
| `platform` | `text` | yes |  |
| `mode` | `one of on my say-so \| on my own submit \| ask me on this platform \| every page I open \| never` | yes |  |
| `default_scope` | `one of this item \| this thread \| this channel as shown \| this page \| this meeting \| my outbound message` | yes |  |
| `redactions` | [RedactionRule](/concepts/redactionrule) | no | the person's own |
| `browser_grant` | `one of given \| not given \| not needed` | yes |  |
| `way` | [AccessMethod](/concepts/accessmethod) | no |  |
| `never_captured` | `[text]` | yes | addresses or kinds |



## Routes that use it
- [`/v1/act/capture_rule`](/reference/act/capture_rule) returns it


---
title: "CaptureRuleInput"
description: "a person's capture rule to write: the platform, the mode, the way, the default scope, the never list and the person's redactions"
section: concepts
address: /concepts/captureruleinput
contract: 0476e35e6e275db5
---

# CaptureRuleInput

a person's capture rule to write: the platform, the mode, the way, the default scope, the never list and the person's redactions

[figure: CaptureRuleInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `platform` | `text` | yes |  |
| `mode` | `one of on my say-so \| on my own submit \| ask me on this platform \| every page I open \| never` | yes |  |
| `way` | [AccessMethod](/concepts/accessmethod) | no |  |
| `default_scope` | `one of this item \| this thread \| this channel as shown \| this page \| this meeting \| my outbound message` | yes |  |
| `never_captured` | `[text]` | yes | addresses or kinds |
| `redactions` | [RedactionRule](/concepts/redactionrule) | no | the person's own |
| `browser_grant` | `one of given \| not given \| not needed` | no | the browser's standing host permission for the platform as the extension found it when the rule was written: asked of the person for every page I open, and not needed for the other modes; absent when the rule is written from a surface that is not the browser |



## Routes that use it
- [`/v1/act/capture_rule`](/reference/act/capture_rule) takes it as input


---
title: "CaptureRulesInput"
description: "which capture rules to read: one platform, or all of the person's"
section: concepts
address: /concepts/capturerulesinput
contract: 0476e35e6e275db5
---

# CaptureRulesInput

which capture rules to read: one platform, or all of the person's

[figure: CaptureRulesInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `platform` | `text` | no |  |



## Routes that use it
- [`/v1/read/capture_rules`](/reference/read/capture_rules) takes it as input


---
title: "Card"
description: "the one result of every tool: a typed value, its foot, and what can be done next; it cannot be built without its foot"
section: concepts
address: /concepts/card
contract: 0476e35e6e275db5
---

# Card

the one result of every tool: a typed value, its foot, and what can be done next; it cannot be built without its foot

[figure: Card is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `body_type` | `text` | yes | a type of this register |
| `body` | `json` | yes | the serialisation of that type |
| `text` | `text` | yes | the text face, first |
| `foot` | [CardFoot](/concepts/cardfoot) | yes |  |
| `next` | [NextAction](/concepts/nextaction) | yes |  |
| `basis` | [Basis](/concepts/basis) | yes | shown as a symbol and a word |
| `hypothesis` | `id` | no | for a claim under test: its evidence and tests |
| `archetype` | `one of scorecard \| ranked list \| chart \| key-value \| media \| next move \| record \| document` | no | the generic renderer a card of no registered kind uses; a registered kind names its own |
| `tier` | `one of a step row \| a compact block \| an expanded block \| the canvas` | no | the tier the card opens at |



## Routes that use it
- [`/v1/ask/local`](/reference/ask/local) returns it


---
title: "CardFoot"
description: "what was read, the population, the control with what was expected and what was seen, and the position of each count"
section: concepts
address: /concepts/cardfoot
contract: 0476e35e6e275db5
---

# CardFoot

what was read, the population, the control with what was expected and what was seen, and the position of each count

[figure: CardFoot is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `what_was_read` | `[text]` | yes |  |
| `population` | [PopulationStatement](/concepts/populationstatement) | yes |  |
| `control` | [ControlResult](/concepts/controlresult) | no |  |
| `positions` | `{text:enum:measured \| never measured \| withheld}` | yes |  |
| `as_of` | [TwoDates](/concepts/twodates) | yes |  |
| `tier` | `text` | no | the tier that gave it |
| `read_set` | [TouchedBuckets](/concepts/touchedbuckets) | no | the buckets and snapshots of each table the answer read, so a cached card, a document, a map or a served table knows when its facts changed |



## Routes that use it
No route takes or returns CardFoot directly. The record holds it, and the objects that point at it reach it.


---
title: "CatalogueEntry"
description: "the only way to read a file of the lakehouse"
section: concepts
address: /concepts/catalogueentry
contract: 0476e35e6e275db5
---

# CatalogueEntry

the only way to read a file of the lakehouse

[figure: CatalogueEntry is a definition at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | follows |
| key | the layer, the plane, the source, the day and the version |
| store | postgres |
| family | record |



## Fields


| field | type | required | note |
|---|---|---|---|
| `layer` | `one of as landed \| refined \| ready to use` | yes |  |
| `plane` | [Plane](/concepts/plane) | yes |  |
| `source` | [Source](/concepts/source) | no |  |
| `day` | `date` | no | required only when the table is split by day |
| `files` | [LakeFile](/concepts/lakefile) | yes |  |
| `rows` | `count` | yes |  |
| `made_from` | `[id]` | yes |  |
| `table` | [SilverTable](/concepts/silvertable) | yes |  |
| `bucket` | `count` | no | for a table split by entity bucket |
| `snapshot` | `count` | yes | the lakehouse catalogue's snapshot that is this entry |
| `version` | `count` | yes | the partition's version, from the entry's key |
| `hash` | `hash` | no | the hash of the partition's rows, as the closed partition carries it; the commit carries it |



## Routes that use it
No route takes or returns CatalogueEntry directly. The record holds it, and the objects that point at it reach it.


---
title: "CatalogueInput"
description: "a tenant or a brand, and a filter by source, kind of intelligence or vertical"
section: concepts
address: /concepts/catalogueinput
contract: 0476e35e6e275db5
---

# CatalogueInput

a tenant or a brand, and a filter by source, kind of intelligence or vertical

[figure: CatalogueInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `tenant` | `id` | no |  |
| `brand` | `id` | no |  |
| `filter` | `text` | no |  |



## Routes that use it
- [`/v1/read/catalogue`](/reference/read/catalogue) takes it as input


---
title: "Catch"
description: "a unit admitted by a predicate at a place, with the conditions and the words that admitted it"
section: concepts
address: /concepts/catch
contract: 0476e35e6e275db5
---

# Catch

a unit admitted by a predicate at a place, with the conditions and the words that admitted it

[figure: Catch is a fact at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | follows |
| key | the hash, the unit, the place and the observation read |
| store | postgres+lake |
| family | rules_engine |



## Fields


| field | type | required | note |
|---|---|---|---|
| `predicate` | `hash` | yes |  |
| `unit` | `id` | yes |  |
| `place` | [PlaceARunsAt](/concepts/placearunsat) | yes |  |
| `observation` | `id` | yes |  |
| `conditions` | [ConditionMatch](/concepts/conditionmatch) | yes |  |
| `monitor` | `id` | no |  |



## Routes that use it
- [`/v1/read/explain_catch`](/reference/read/explain_catch) returns it


---
title: "Certificate"
description: "a TLS certificate issued inside the cluster by cert-manager and kept as a secret"
section: concepts
address: /concepts/certificate
contract: 0476e35e6e275db5
---

# Certificate

a TLS certificate issued inside the cluster by cert-manager and kept as a secret

[figure: Certificate is a definition at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | platform |
| key | the host names it covers |
| store | vault |
| family | network |



## Fields


| field | type | required | note |
|---|---|---|---|
| `hosts` | `[text]` | yes |  |
| `issuer` | `text` | yes |  |
| `not_before` | `time` | yes |  |
| `not_after` | `time` | yes |  |
| `secret` | [VaultEntry](/concepts/vaultentry) | yes | where the key is kept; never on disk in a file |
| `renew_before` | `duration` | yes | the alarm and the renewal fire this long before expiry |



## Routes that use it
No route takes or returns Certificate directly. The record holds it, and the objects that point at it reach it.


---
title: "Chain"
description: "the parties around a sale, each handing demand to the next; its stocks with a side and a reader, its handovers counted as facts, its leaks"
section: concepts
address: /concepts/chain
contract: 0476e35e6e275db5
---

# Chain

the parties around a sale, each handing demand to the next; its stocks with a side and a reader, its handovers counted as facts, its leaks

[figure: Chain is a definition at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | platform |
| key | the vertical |
| store | postgres |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `vertical` | `id` | yes |  |
| `stocks` | [ChainStock](/concepts/chainstock) | yes |  |
| `handovers` | [ChainHandover](/concepts/chainhandover) | yes |  |
| `leaks` | [Leak](/concepts/leak) | yes |  |
| `loop` | `text` | yes |  |



## Routes that use it
- [`/v1/read/chain`](/reference/read/chain) returns it


---
title: "ChainHandover"
description: "a flow between two stocks, with its count as a fact"
section: concepts
address: /concepts/chainhandover
contract: 0476e35e6e275db5
---

# ChainHandover

a flow between two stocks, with its count as a fact

[figure: ChainHandover is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `from` | `text` | yes |  |
| `to` | `text` | yes |  |
| `what` | `text` | yes |  |
| `count` | [Summary](/concepts/summary) | yes |  |
| `country` | `text` | no |  |
| `money_per_unit` | [NumberInPosition](/concepts/numberinposition) | no | by payer and setting, measured, estimated or stipulated |
| `rail` | `text` | no | the payment rail, where the handover splits by it |
| `permission` | `id` | no | the permission held that gates the handover |



## Routes that use it
No route takes or returns ChainHandover directly. The record holds it, and the objects that point at it reach it.


---
title: "ChainStock"
description: "one stock of a chain, with its side, its unit, its reader and a count with its basis"
section: concepts
address: /concepts/chainstock
contract: 0476e35e6e275db5
---

# ChainStock

one stock of a chain, with its side, its unit, its reader and a count with its basis

[figure: ChainStock is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `side` | `one of demand \| supply \| intermediary \| influence \| rules` | yes |  |
| `unit` | `text` | yes |  |
| `reader` | `text` | yes | a stock with no reader is a leak |
| `count` | [Summary](/concepts/summary) | yes |  |
| `roles` | [RoleAroundADecision](/concepts/rolearoundadecision) | yes |  |
| `country` | `text` | no | where the stock sits, for a chain read country by country |
| `waiting` | `duration` | no | how long a unit may wait on the stock |
| `admits` | [Predicate](/concepts/predicate) | no | the rule for which units the stock admits |
| `splittable` | `bool` | no | false where the stock is read but cannot be split apart, such as a payment processor |



## Routes that use it
No route takes or returns ChainStock directly. The record holds it, and the objects that point at it reach it.


---
title: "Change"
description: "a merged commit on the main branch, with the part of the plan it moves and the checks that completed at it"
section: concepts
address: /concepts/change
contract: 0476e35e6e275db5
---

# Change

a merged commit on the main branch, with the part of the plan it moves and the checks that completed at it

[figure: Change is a fact at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | platform |
| key | the commit |
| store | postgres |
| family | releases |



## Fields


| field | type | required | note |
|---|---|---|---|
| `repository` | `text` | yes |  |
| `commit` | `hash` | yes |  |
| `subject` | `text` | yes | one complete sentence with a verb |
| `body` | `text` | yes |  |
| `moves` | `text` | yes |  |
| `checks` | [ControlResult](/concepts/controlresult) | yes |  |



## Routes that use it
No route takes or returns Change directly. The record holds it, and the objects that point at it reach it.


---
title: "ChangePlanInput"
description: "the plan kind to change to"
section: concepts
address: /concepts/changeplaninput
contract: 0476e35e6e275db5
---

# ChangePlanInput

the plan kind to change to

[figure: ChangePlanInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `plan_kind` | `one of trial \| paid \| internal` | yes |  |



## Routes that use it
- [`/v1/act/change_plan`](/reference/act/change_plan) takes it as input


---
title: "ChannelCoverage"
description: "one channel's coverage in an answer"
section: concepts
address: /concepts/channelcoverage
contract: 0476e35e6e275db5
---

# ChannelCoverage

one channel's coverage in an answer

[figure: ChannelCoverage is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | rules_engine |



## Fields


| field | type | required | note |
|---|---|---|---|
| `channel` | [Source](/concepts/source) | yes |  |
| `state` | `one of matched \| empty after a real scan \| never measured` | yes |  |
| `scanned` | `count` | no |  |
| `matched` | `count` | no |  |
| `reason` | `one of never acquired \| not acquired in this window \| the bound ran out` | no |  |
| `repair` | `text` | no |  |



## Routes that use it
No route takes or returns ChannelCoverage directly. The record holds it, and the objects that point at it reach it.


---
title: "ChannelRule"
description: "a channel with its rule"
section: concepts
address: /concepts/channelrule
contract: 0476e35e6e275db5
---

# ChannelRule

a channel with its rule

[figure: ChannelRule is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `community` | `id` | yes |  |
| `rule` | `text` | yes |  |



## Routes that use it
No route takes or returns ChannelRule directly. The record holds it, and the objects that point at it reach it.


---
title: "ChippedNumber"
description: "a number in a document, with the unit that supplied it and its instrument"
section: concepts
address: /concepts/chippednumber
contract: 0476e35e6e275db5
---

# ChippedNumber

a number in a document, with the unit that supplied it and its instrument

[figure: ChippedNumber is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | documents |



## Fields


| field | type | required | note |
|---|---|---|---|
| `label` | `text` | yes |  |
| `value` | `json` | yes |  |
| `unit` | `id` | yes |  |
| `instrument` | `text` | yes |  |
| `basis` | [Basis](/concepts/basis) | yes |  |



## Routes that use it
No route takes or returns ChippedNumber directly. The record holds it, and the objects that point at it reach it.


---
title: "Claim"
description: "an attribute of an entity, from one source, for a time"
section: concepts
address: /concepts/claim
contract: 0476e35e6e275db5
---

# Claim

an attribute of an entity, from one source, for a time

[figure: Claim is a fact at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | follows |
| key | the entity, the attribute, the source and the time it was true |
| store | lake:ready |
| family | record |



## Fields


| field | type | required | note |
|---|---|---|---|
| `entity` | `id` | yes |  |
| `attribute` | `text` | yes |  |
| `value` | `json` | yes |  |
| `from_when` | `time` | no |  |
| `until_when` | `time` | no |  |
| `identity_decision` | `id` | yes | the decision it was attached under |



## Routes that use it
No route takes or returns Claim directly. The record holds it, and the objects that point at it reach it.


---
title: "ClassPass"
description: "one pass of the beat that reads the class of every armed play from the rivals' coverage of its kind against the parameter's count: a reading written for each, the class moved where the reading moved, and the claim under test settled and made again"
section: concepts
address: /concepts/classpass
contract: 0476e35e6e275db5
---

# ClassPass

one pass of the beat that reads the class of every armed play from the rivals' coverage of its kind against the parameter's count: a reading written for each, the class moved where the reading moved, and the claim under test settled and made again

[figure: ClassPass is a work at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | work |
| scope | platform |
| key | the beat's tick |
| store | postgres |
| family | strategy |



## Fields


| field | type | required | note |
|---|---|---|---|
| `plays` | `count` | yes | the armed plays read |
| `readings` | `count` | yes | class readings written |
| `moved` | `count` | yes | plays whose class moved |
| `withheld` | `count` | yes | plays whose class could not be read, with the reason on the play |
| `at` | `time` | yes |  |



## Routes that use it
No route takes or returns ClassPass directly. The record holds it, and the objects that point at it reach it.


---
title: "ClassReading"
description: "a play's class read on a beat from the rivals' coverage, the effect against the tide and the twin's sensitivity; moved when the reading moves, with its event"
section: concepts
address: /concepts/classreading
contract: 0476e35e6e275db5
---

# ClassReading

a play's class read on a beat from the rivals' coverage, the effect against the tide and the twin's sensitivity; moved when the reading moves, with its event

[figure: ClassReading is a fact at strategy scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | strategy |
| key | the play, its version and the beat |
| store | postgres+lake |
| family | strategy |



## Fields


| field | type | required | note |
|---|---|---|---|
| `play` | `id` | yes |  |
| `play_version` | `count` | yes |  |
| `class` | [PlayClass](/concepts/playclass) | yes |  |
| `coverage` | `count` | yes | the rivals running the kind of play in the market |
| `sensitivity` | `share` | no | the twin's trajectory's change per unit of the intervention; never measured before a simulation |
| `effect_against_tide` | [Interval](/concepts/interval) | no |  |
| `moved` | `bool` | yes | true when the class differs from the reading before |
| `hypothesis` | `id` | yes |  |
| `beat` | `id` | yes |  |
| `read_at` | `time` | yes |  |



## Routes that use it
No route takes or returns ClassReading directly. The record holds it, and the objects that point at it reach it.


---
title: "Client"
description: "an application that asks for tokens: our web interface, our desktop interface, an outside agent, the acquisition system's host, the capture extension"
section: concepts
address: /concepts/client
contract: 0476e35e6e275db5
---

# Client

an application that asks for tokens: our web interface, our desktop interface, an outside agent, the acquisition system's host, the capture extension

[figure: Client is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | its id or its published address |
| store | postgres |
| family | people |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `kind` | `one of our web interface \| our desktop interface \| an outside agent \| the crawler \| a customer's program` | yes |  |
| `access_scopes_allowed` | [AccessScope](/concepts/accessscope) | yes |  |
| `redirects` | `[address]` | yes | where it may send a person back |
| `published_description` | `address` | no | for an outside agent made on request |
| `key_binding` | `bool` | yes | whether its tokens are tied to its key |
| `made_on_request` | `bool` | yes |  |
| `state` | [Readiness](/concepts/readiness) | yes |  |



## Routes that use it
No route takes or returns Client directly. The record holds it, and the objects that point at it reach it.


---
title: "ClientConnection"
description: "one WebSocket the installed app keeps open to the platform: authenticated by the session's token in its first message, carrying progress, task events and file bytes"
section: concepts
address: /concepts/clientconnection
contract: 0476e35e6e275db5
---

# ClientConnection

one WebSocket the installed app keeps open to the platform: authenticated by the session's token in its first message, carrying progress, task events and file bytes

[figure: ClientConnection is a fact at tenant scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | tenant |
| key | the session and the connection id |
| store | postgres |
| family | network |



## Fields


| field | type | required | note |
|---|---|---|---|
| `session` | `id` | yes |  |
| `opened_at` | `time` | yes |  |
| `last_message_at` | `time` | yes |  |
| `bytes_in` | `bytes` | yes |  |
| `bytes_out` | `bytes` | yes |  |
| `state` | `one of open \| idle \| closed` | yes |  |



## Routes that use it
No route takes or returns ClientConnection directly. The record holds it, and the objects that point at it reach it.


---
title: "ClientInfo"
description: "what a client states about itself in the handshake"
section: concepts
address: /concepts/clientinfo
contract: 0476e35e6e275db5
---

# ClientInfo

what a client states about itself in the handshake

[figure: ClientInfo is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `title` | `text` | yes |  |
| `version` | `text` | yes |  |



## Routes that use it
No route takes or returns ClientInfo directly. The record holds it, and the objects that point at it reach it.


---
title: "ClosedPartition"
description: "a closed partition of the refined layer; final, with the hash of its rows"
section: concepts
address: /concepts/closedpartition
contract: 0476e35e6e275db5
---

# ClosedPartition

a closed partition of the refined layer; final, with the hash of its rows

[figure: ClosedPartition is a fact at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | follows |
| key | the partition and its number |
| store | lake:refined |
| family | record |



## Fields


| field | type | required | note |
|---|---|---|---|
| `layer` | `one of refined` | yes |  |
| `plane` | [Plane](/concepts/plane) | yes |  |
| `source` | [Source](/concepts/source) | yes |  |
| `day` | `date` | yes |  |
| `number` | `count` | yes |  |
| `rows` | `count` | yes |  |
| `rows_hash` | `hash` | yes |  |
| `files` | [LakeFile](/concepts/lakefile) | yes |  |
| `closed_at` | `time` | yes |  |
| `closed_because` | `one of longest age \| row cap \| adopted whole` | yes | adopted whole: the platform did not build this partition. The connector's own parser had already written one month of the archive as files, and the engine registered those files as they stand (18 §2.12). |
| `table` | [SilverTable](/concepts/silvertable) | no |  |
| `bucket` | `count` | no |  |



## Routes that use it
No route takes or returns ClosedPartition directly. The record holds it, and the objects that point at it reach it.


---
title: "ClusterCard"
description: "a group of subjects with the share of each layer first, its lists, its trend, the proxies that placed it, and how it was cut"
section: concepts
address: /concepts/clustercard
contract: 0476e35e6e275db5
---

# ClusterCard

a group of subjects with the share of each layer first, its lists, its trend, the proxies that placed it, and how it was cut

[figure: ClusterCard is a view at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | follows |
| key | the group and the cut |
| store | derived |
| family | models |



## Fields


| field | type | required | note |
|---|---|---|---|
| `group` | `id` | yes |  |
| `layers` | [LayerOfLikeness](/concepts/layeroflikeness) | yes |  |
| `top_communities` | `[id]` | yes |  |
| `top_words` | `[text]` | yes |  |
| `top_domains` | `[text]` | yes |  |
| `size` | `count` | yes |  |
| `trend_by_month` | `{text:count}` | yes |  |
| `proxies` | `[id]` | yes |  |
| `resolution` | `share` | yes |  |
| `seed` | `text` | no |  |
| `sample` | `[id]` | yes |  |



## Routes that use it
No route takes or returns ClusterCard directly. The record holds it, and the objects that point at it reach it.


---
title: "Collector"
description: "the one OpenTelemetry collector: its receivers, its processors, and its exporters"
section: concepts
address: /concepts/collector
contract: 0476e35e6e275db5
---

# Collector

the one OpenTelemetry collector: its receivers, its processors, and its exporters

[figure: Collector is a definition at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | platform |
| key | its name |
| store | postgres |
| family | observability |



## Fields


| field | type | required | note |
|---|---|---|---|
| `receivers` | `[one of otlp-grpc \| otlp-http]` | yes |  |
| `processors` | `[one of redact-secrets \| attribute-allow-list \| batch \| memory-limit]` | yes | redaction runs first |
| `exporters` | [SignalExport](/concepts/signalexport) | yes |  |
| `listener` | [Listener](/concepts/listener) | yes | on the private network only |
| `buffer_limit_bytes` | `bytes` | yes | a role's local buffer when the collector is unreachable; past it, metrics are dropped and a request is never blocked |



## Routes that use it
No route takes or returns Collector directly. The record holds it, and the objects that point at it reach it.


---
title: "Column"
description: "one column of a served table"
section: concepts
address: /concepts/column
contract: 0476e35e6e275db5
---

# Column

one column of a served table

[figure: Column is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | rules_engine |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `type` | `text` | yes | a type of this register or a primitive |
| `version` | `count` | yes |  |
| `required` | `bool` | no | whether every row must carry it; for a served table's columns, absent |



## Routes that use it
No route takes or returns Column directly. The record holds it, and the objects that point at it reach it.


---
title: "Community"
description: "a room where people gather"
section: concepts
address: /concepts/community
contract: 0476e35e6e275db5
---

# Community

a room where people gather

[figure: Community is a entity at shared scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | entity |
| scope | shared |
| key | the platform and its own id |
| store | postgres |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `platform` | `text` | yes |  |
| `name` | `text` | yes |  |
| `members` | `count` | no |  |
| `posture` | [CommunityPosture](/concepts/communityposture) | no |  |



## Routes that use it
No route takes or returns Community directly. The record holds it, and the objects that point at it reach it.


---
title: "CommunityPosture"
description: "open, conditional, closed or unknown, from the removal rates in the room"
section: concepts
address: /concepts/communityposture
contract: 0476e35e6e275db5
---

# CommunityPosture

open, conditional, closed or unknown, from the removal rates in the room

[figure: CommunityPosture is a fact at shared scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | shared |
| key | the community and the window |
| store | postgres+lake |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `community` | `id` | yes |  |
| `window` | [Window](/concepts/window) | yes |  |
| `posture` | `one of open \| conditional \| closed \| unknown` | yes |  |
| `removed_with_link` | `share` | no |  |
| `removed_without_link` | `share` | no |  |
| `archetype` | `text` | no |  |



## Routes that use it
- [`/v1/read/posture`](/reference/read/posture) returns it


---
title: "Company"
description: "a company, an entity of the record"
section: concepts
address: /concepts/company
contract: 0476e35e6e275db5
---

# Company

a company, an entity of the record

[figure: Company is a entity at shared scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | entity |
| scope | shared |
| key | decided |
| store | postgres |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `brands` | `[id]` | yes |  |
| `legal_entities` | `[id]` | yes |  |
| `website` | `text` | no |  |
| `place` | `id` | no |  |



## Routes that use it
No route takes or returns Company directly. The record holds it, and the objects that point at it reach it.


---
title: "CompareInput"
description: "two brands and a question from the closed list"
section: concepts
address: /concepts/compareinput
contract: 0476e35e6e275db5
---

# CompareInput

two brands and a question from the closed list

[figure: CompareInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `first` | `id` | yes |  |
| `second` | `id` | yes |  |
| `question` | [ComparisonQuestion](/concepts/comparisonquestion) | yes |  |



## Routes that use it
- [`/v1/read/compare`](/reference/read/compare) takes it as input


---
title: "Comparison"
description: "two summaries over one structure, each with its coverage"
section: concepts
address: /concepts/comparison
contract: 0476e35e6e275db5
---

# Comparison

two summaries over one structure, each with its coverage

[figure: Comparison is a view at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `question` | [ComparisonQuestion](/concepts/comparisonquestion) | yes |  |
| `first` | [Summary](/concepts/summary) | yes |  |
| `second` | [Summary](/concepts/summary) | yes |  |



## Routes that use it
- [`/v1/read/compare`](/reference/read/compare) returns it


---
title: "ComparisonQuestion"
description: "one of the closed list of comparisons"
section: concepts
address: /concepts/comparisonquestion
contract: 0476e35e6e275db5
---

# ComparisonQuestion

one of the closed list of comparisons

[figure: ComparisonQuestion is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | its name |
| store | postgres |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `structure` | `[text]` | yes | the summaries it reads |



## Routes that use it
No route takes or returns ComparisonQuestion directly. The record holds it, and the objects that point at it reach it.


---
title: "Concept"
description: "a named meaning a predicate may name; never a phrase"
section: concepts
address: /concepts/concept
contract: 0476e35e6e275db5
---

# Concept

a named meaning a predicate may name; never a phrase

[figure: Concept is a definition at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | follows |
| key | its name and its owner |
| store | postgres |
| family | record |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `definition` | `text` | yes |  |
| `labelled_examples` | `[id]` | yes |  |
| `vectors` | [Vector](/concepts/vector) | yes | under each ready model |
| `floor` | `share` | yes |  |
| `review_band` | [Interval](/concepts/interval) | yes |  |



## Routes that use it
No route takes or returns Concept directly. The record holds it, and the objects that point at it reach it.


---
title: "ConceptBars"
description: "the meaning bars of one concept under the model the bars were measured under: the score at each breadth's share for that concept alone, so a leaf's breadth means the same share whatever its concept"
section: concepts
address: /concepts/conceptbars
contract: 0476e35e6e275db5
---

# ConceptBars

the meaning bars of one concept under the model the bars were measured under: the score at each breadth's share for that concept alone, so a leaf's breadth means the same share whatever its concept

[figure: ConceptBars is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | rules_engine |



## Fields


| field | type | required | note |
|---|---|---|---|
| `concept_hash` | `hash` | yes | the hash of the concept's text |
| `exact` | `share` | yes |  |
| `similar` | `share` | yes |  |
| `related` | `share` | yes |  |
| `broad` | `share` | yes |  |
| `units` | `count` | yes | the units the concept was ranked over |



## Routes that use it
No route takes or returns ConceptBars directly. The record holds it, and the objects that point at it reach it.


---
title: "ConceptWeight"
description: "one concept with its weight in an entity's content affinity, and the evidence that carries it"
section: concepts
address: /concepts/conceptweight
contract: 0476e35e6e275db5
---

# ConceptWeight

one concept with its weight in an entity's content affinity, and the evidence that carries it

[figure: ConceptWeight is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | models |



## Fields


| field | type | required | note |
|---|---|---|---|
| `concept` | `id` | yes | a concept row |
| `weight` | `share` | yes |  |
| `evidence` | [EvidenceRef](/concepts/evidenceref) | yes | a weight without evidence cannot be written |



## Routes that use it
No route takes or returns ConceptWeight directly. The record holds it, and the objects that point at it reach it.


---
title: "ConditionMatch"
description: "one condition that admitted a match"
section: concepts
address: /concepts/conditionmatch
contract: 0476e35e6e275db5
---

# ConditionMatch

one condition that admitted a match

[figure: ConditionMatch is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | rules_engine |



## Fields


| field | type | required | note |
|---|---|---|---|
| `condition` | `text` | yes |  |
| `words_matched` | `[text]` | yes |  |
| `confidence` | `share` | yes |  |



## Routes that use it
No route takes or returns ConditionMatch directly. The record holds it, and the objects that point at it reach it.


---
title: "Connection"
description: "a connection with any number of members, one row for the connection and one for each member"
section: concepts
address: /concepts/connection
contract: 0476e35e6e275db5
---

# Connection

a connection with any number of members, one row for the connection and one for each member

[figure: Connection is a fact at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | follows |
| key | its kind, its members with their roles, the source and the time |
| store | lake:ready |
| family | record |



## Fields


| field | type | required | note |
|---|---|---|---|
| `kind` | [KindOfConnection](/concepts/kindofconnection) | yes |  |
| `members` | [ConnectionMember](/concepts/connectionmember) | yes | each with its role; a member's kind must be one its role allows |
| `adds` | `json` | no | what the kind adds: a share, a code, a weight, a period |
| `period` | `text` | no | for co-presence: the month |
| `weight` | `count` | no | whole millionths, so a collapse over months is the same in any order of rows |
| `recipe_version` | `text` | no |  |



## Routes that use it
No route takes or returns Connection directly. The record holds it, and the objects that point at it reach it.


---
title: "ConnectionLimits"
description: "the bounds on one connection: request deadline, body size, idle timeout of a WebSocket, and connections per client address"
section: concepts
address: /concepts/connectionlimits
contract: 0476e35e6e275db5
---

# ConnectionLimits

the bounds on one connection: request deadline, body size, idle timeout of a WebSocket, and connections per client address

[figure: ConnectionLimits is a parameter at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | parameter |
| scope | platform |
| key | the listener |
| store | postgres |
| family | network |



## Fields


| field | type | required | note |
|---|---|---|---|
| `request_deadline` | `duration` | yes |  |
| `max_body_bytes` | `bytes` | yes |  |
| `websocket_idle_timeout` | `duration` | yes |  |
| `max_connections_per_client` | `count` | yes |  |



## Routes that use it
No route takes or returns ConnectionLimits directly. The record holds it, and the objects that point at it reach it.


---
title: "ConnectionMember"
description: "one member of a connection, with its role"
section: concepts
address: /concepts/connectionmember
contract: 0476e35e6e275db5
---

# ConnectionMember

one member of a connection, with its role

[figure: ConnectionMember is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | record |



## Fields


| field | type | required | note |
|---|---|---|---|
| `unit` | `id` | yes | an entity, or a connection |
| `role` | `text` | yes |  |
| `weight` | `count` | no | the membership's weight in whole millionths |



## Routes that use it
No route takes or returns ConnectionMember directly. The record holds it, and the objects that point at it reach it.


---
title: "ConnectionRole"
description: "a role a member may play"
section: concepts
address: /concepts/connectionrole
contract: 0476e35e6e275db5
---

# ConnectionRole

a role a member may play

[figure: ConnectionRole is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | record |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `allowed_kinds` | [KindOfEntity](/concepts/kindofentity) | yes |  |
| `allowed_definitions` | `[one of a buyer profile \| a segment \| a play \| a proxy \| a ladder \| a document]` | no | the kinds of definition a member may be, such as a buyer profile for the connection written for |
| `optional` | `bool` | no | true when a connection of the kind may omit the role: a rivalry a source states without its segment or place is still a rivalry |
| `cardinality` | `one of one \| many` | yes |  |



## Routes that use it
No route takes or returns ConnectionRole directly. The record holds it, and the objects that point at it reach it.


---
title: "ConnectionState"
description: "the one WebSocket a session keeps to the platform, as the status bar shows it"
section: concepts
address: /concepts/connectionstate
contract: 0476e35e6e275db5
---

# ConnectionState

the one WebSocket a session keeps to the platform, as the status bar shows it

[figure: ConnectionState is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | interfaces |



## Fields


| field | type | required | note |
|---|---|---|---|
| `state` | `one of connecting \| open \| degraded \| closed` | yes |  |
| `opened_at` | `time` | no |  |
| `last_message_at` | `time` | no |  |
| `cursor` | [EventCursor](/concepts/eventcursor) | no |  |
| `retries` | `count` | yes |  |



## Routes that use it
No route takes or returns ConnectionState directly. The record holds it, and the objects that point at it reach it.


---
title: "Connector"
description: "the code for one source's ways and actions, with what it declares; one package of rows plus one implementation (18 §2.1)"
section: concepts
address: /concepts/connector
contract: 0476e35e6e275db5
---

# Connector

the code for one source's ways and actions, with what it declares; one package of rows plus one implementation (18 §2.1)

[figure: Connector is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | its name and the version of its code |
| store | postgres |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `source` | [Source](/concepts/source) | no | absent for a connector parameterized by its declarations, such as the browser capture, whose declarations each name theirs |
| `code_version` | `text` | yes |  |
| `declares` | `[text]` | yes | The names of the kinds of reading, the kinds of action and the capture declarations whose rows name this connector. The register build derives the list from those rows; nobody types it. |
| `behaviours` | `[one of probe \| read \| subscribe \| backfill \| act \| undo \| resolve \| capture]` | yes | the trait's behaviours the rows declare; one not implemented fails the build |
| `samples_hash` | `hash` | no | the recorded wire captures |
| `samples` | `{text:hash}` | no | for a connector that writes more than one shape (a catalogue builder whose views differ), the checked schema hash of each source object it returns, by the object's name; a connector that writes one shape records samples_hash alone |
| `sync_offers` | [SyncOffer](/concepts/syncoffer) | yes |  |
| `state` | [Readiness](/concepts/readiness) | yes |  |



## Routes that use it
No route takes or returns Connector directly. The record holds it, and the objects that point at it reach it.


---
title: "ConnectorOffer"
description: "every kind of reading and of action, by source, with its state, the identity it needs, its cost and its rights"
section: concepts
address: /concepts/connectoroffer
contract: 0476e35e6e275db5
---

# ConnectorOffer

every kind of reading and of action, by source, with its state, the identity it needs, its cost and its rights

[figure: ConnectorOffer is a view at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `readings` | [KindOfReading](/concepts/kindofreading) | yes |  |
| `actions` | [KindOfAction](/concepts/kindofaction) | yes |  |
| `installed` | [InstalledConnector](/concepts/installedconnector) | yes |  |



## Routes that use it
- [`/v1/read/connectors`](/reference/read/connectors) returns it


---
title: "ConnectorsInput"
description: "a tenant or a brand"
section: concepts
address: /concepts/connectorsinput
contract: 0476e35e6e275db5
---

# ConnectorsInput

a tenant or a brand

[figure: ConnectorsInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `tenant` | `id` | no |  |
| `brand` | `id` | no |  |



## Routes that use it
- [`/v1/read/connectors`](/reference/read/connectors) takes it as input
- [`/v1/read/failed_calls`](/reference/read/failed_calls) takes it as input


---
title: "Consent"
description: "consent given, with its evidence; a later fact ends it"
section: concepts
address: /concepts/consent
contract: 0476e35e6e275db5
---

# Consent

consent given, with its evidence; a later fact ends it

[figure: Consent is a fact at tenant scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | tenant |
| key | the person or tenant, the use and the moment |
| store | postgres |
| family | people |



## Fields


| field | type | required | note |
|---|---|---|---|
| `subject` | `id` | yes | the person or the tenant |
| `use` | `text` | yes |  |
| `how` | `text` | yes |  |
| `evidence` | `[id]` | yes |  |
| `withdrawn` | `bool` | yes |  |



## Routes that use it
No route takes or returns Consent directly. The record holds it, and the objects that point at it reach it.


---
title: "ConsentAnswer"
description: "a fact, or yes or no with the fact that decides"
section: concepts
address: /concepts/consentanswer
contract: 0476e35e6e275db5
---

# ConsentAnswer

a fact, or yes or no with the fact that decides

[figure: ConsentAnswer is a view at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `answer` | `one of yes \| no` | no |  |
| `fact` | [Consent](/concepts/consent) | no |  |



## Routes that use it
- [`/v1/read/consent`](/reference/read/consent) returns it


---
title: "ConsentInput"
description: "the person or tenant, and the use; to record, withdraw or ask"
section: concepts
address: /concepts/consentinput
contract: 0476e35e6e275db5
---

# ConsentInput

the person or tenant, and the use; to record, withdraw or ask

[figure: ConsentInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `subject` | `id` | yes |  |
| `use` | `text` | yes |  |
| `do` | `one of record \| withdraw \| ask` | yes |  |
| `how` | `text` | no |  |
| `evidence` | `[id]` | no |  |



## Routes that use it
- [`/v1/read/consent`](/reference/read/consent) takes it as input


---
title: "ConsolePanel"
description: "one panel of the ops console: the levels, stocks or alarms it draws, and the query it runs over the signal store"
section: concepts
address: /concepts/consolepanel
contract: 0476e35e6e275db5
---

# ConsolePanel

one panel of the ops console: the levels, stocks or alarms it draws, and the query it runs over the signal store

[figure: ConsolePanel is a definition at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | platform |
| key | its name |
| store | postgres |
| family | observability |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `draws` | `[text]` | yes | level, stock or alarm names |
| `query` | `text` | yes | read-only SQL over the signal store and the served tables |
| `audience` | `one of platform-administrator` | yes | the console is exposed to administrators alone |



## Routes that use it
No route takes or returns ConsolePanel directly. The record holds it, and the objects that point at it reach it.


---
title: "ContactKind"
description: "one way a person or a company is reached or found anywhere on the web, as the extension reads it on every page and the accept keys it: an email, a phone, a handle on a platform, an invite, a site; found by the addresses of links, by a pattern over the visible text, or by a bare handle near a cue word; it becomes an…"
section: concepts
address: /concepts/contactkind
contract: 0476e35e6e275db5
---

# ContactKind

one way a person or a company is reached or found anywhere on the web, as the extension reads it on every page and the accept keys it: an email, a phone, a handle on a platform, an invite, a site; found by the addresses of links, by a pattern over the visible text, or by a bare handle near a cue word; it becomes an…

[figure: ContactKind is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | its name |
| store | postgres |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `namespace` | `text` | yes | the identifier namespace a found value becomes |
| `of` | `one of a person \| a company \| either` | yes |  |
| `link_patterns` | `[text]` | yes | address patterns of links that are this kind, a * for any run; mailto:* and tel:* included |
| `text_pattern` | `text` | no | a regular expression over the visible text, with one capturing group for the value |
| `cue_words` | `[text]` | yes | words near a bare @handle that make it this kind |
| `platform` | `text` | no | the platform whose own pages make a bare @handle this kind |
| `normalisation` | `one of lowercase \| strip the at sign \| strip the scheme \| digits only \| the host only \| as is` | yes |  |
| `trust_rank` | `count` | yes | 1 decides sameness, 2 supports it, 3 is a hint |
| `catch_all` | `bool` | yes | read last, for a link that no other kind claims |



## Routes that use it
No route takes or returns ContactKind directly. The record holds it, and the objects that point at it reach it.


---
title: "ContentAffinity"
description: "what an entity publishes, likes, stars, replies to and follows across every connector, as concept weights with their evidence over a window, kept and re-read on the beat"
section: concepts
address: /concepts/contentaffinity
contract: 0476e35e6e275db5
---

# ContentAffinity

what an entity publishes, likes, stars, replies to and follows across every connector, as concept weights with their evidence over a window, kept and re-read on the beat

[figure: ContentAffinity is a fact at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | follows |
| key | the entity and the window |
| store | postgres+lake |
| family | models |



## Fields


| field | type | required | note |
|---|---|---|---|
| `entity` | `id` | yes |  |
| `window` | [Window](/concepts/window) | yes |  |
| `concepts` | [ConceptWeight](/concepts/conceptweight) | yes |  |
| `sources` | `[id]` | yes | the sources read |
| `units` | `count` | yes | the units of the record behind it |
| `basis` | [Basis](/concepts/basis) | yes |  |
| `as_of` | [TwoDates](/concepts/twodates) | yes |  |



## Routes that use it
No route takes or returns ContentAffinity directly. The record holds it, and the objects that point at it reach it.


---
title: "ContentItem"
description: "a piece of content, the same by construction"
section: concepts
address: /concepts/contentitem
contract: 0476e35e6e275db5
---

# ContentItem

a piece of content, the same by construction

[figure: ContentItem is a entity at shared scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | entity |
| scope | shared |
| key | the source and the source's own id |
| store | postgres+lake |
| family | record |



## Fields


| field | type | required | note |
|---|---|---|---|
| `versions` | `[hash]` | yes | each the hash of its content |
| `author_account` | `id` | no |  |
| `parent` | `id` | no |  |
| `root` | `id` | no | a reply is a member of its thread and never a thread |
| `community` | `id` | no |  |
| `kind` | [KindOfEntity](/concepts/kindofentity) | yes | a kind whose parent kind is the content item: a post, a comment, a page, a job posting, a filing, a listing, a message, a review, a video, an episode, a transcript segment, an image, an ad creative, a paper, a patent |
| `span` | `json` | no | a start, an end and a unit, seconds, characters or a page, within its parent |



## Routes that use it
No route takes or returns ContentItem directly. The record holds it, and the objects that point at it reach it.


---
title: "ContentRequest"
description: "get_content: one address read as the person or the platform, with what to return and what may be downloaded"
section: concepts
address: /concepts/contentrequest
contract: 0476e35e6e275db5
---

# ContentRequest

get_content: one address read as the person or the platform, with what to return and what may be downloaded

[figure: ContentRequest is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `address` | `text` | yes |  |
| `returns` | `[one of article \| html \| markdown \| text \| links \| metadata \| stylesheets \| scripts \| images \| screenshot \| pdf \| network events]` | yes | article is the main content with its title, author, published time and language, as CrawlKit's extractor returns it |
| `filter` | [ResourceFilter](/concepts/resourcefilter) | yes |  |
| `as_identity` | `id` | no | a held identity, lent by a grant: its cookie jar, session token, access token or API key |
| `proxy_policy` | [ProxyPolicy](/concepts/proxypolicy) | no |  |
| `wait_for` | `text` | no | a selector or a time |
| `cache_for` | `duration` | no |  |
| `credit_cells` | `[id]` | no |  |



## Routes that use it
- [`/v1/ask/get_content`](/reference/ask/get_content) takes it as input


---
title: "ContentResponse"
description: "what get_content returned: each requested form, the article's fields where asked, the artefact's hash in bronze, the bytes by resource type, and the identity that served it"
section: concepts
address: /concepts/contentresponse
contract: 0476e35e6e275db5
---

# ContentResponse

what get_content returned: each requested form, the article's fields where asked, the artefact's hash in bronze, the bytes by resource type, and the identity that served it

[figure: ContentResponse is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `address` | `text` | yes |  |
| `artefact_hash` | `hash` | yes |  |
| `forms` | `{text:text}` | yes | each requested form by name |
| `article` | [ExtractedArticle](/concepts/extractedarticle) | no | when article was asked for |
| `bytes_by_type` | `{text:count}` | yes |  |
| `blocked` | `{text:count}` | yes | what the filter refused, by type |
| `identity` | `id` | no |  |
| `hops` | [HopStamp](/concepts/hopstamp) | yes |  |



## Routes that use it
- [`/v1/ask/get_content`](/reference/ask/get_content) returns it


---
title: "Contribution"
description: "one ask's contribution to a demand statement"
section: concepts
address: /concepts/contribution
contract: 0476e35e6e275db5
---

# Contribution

one ask's contribution to a demand statement

[figure: Contribution is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `ask` | `id` | yes |  |
| `cell_key` | `text` | yes |  |
| `fields` | `[text]` | yes |  |
| `depth` | `text` | yes |  |
| `deadline` | `time` | no |  |



## Routes that use it
No route takes or returns Contribution directly. The record holds it, and the objects that point at it reach it.


---
title: "ControlResult"
description: "a control and what it read"
section: concepts
address: /concepts/controlresult
contract: 0476e35e6e275db5
---

# ControlResult

a control and what it read

[figure: ControlResult is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | rules_engine |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `expected` | `text` | yes | what it must land at |
| `read` | `text` | yes |  |
| `passed` | `bool` | yes |  |
| `at` | `time` | yes |  |



## Routes that use it
No route takes or returns ControlResult directly. The record holds it, and the objects that point at it reach it.


---
title: "CorrectInput"
description: "the event to correct, and the correction"
section: concepts
address: /concepts/correctinput
contract: 0476e35e6e275db5
---

# CorrectInput

the event to correct, and the correction

[figure: CorrectInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `event` | `id` | yes |  |
| `correction` | [Event](/concepts/event) | yes |  |
| `why` | `text` | yes |  |



## Routes that use it
- [`/v1/act/correct`](/reference/act/correct) takes it as input


---
title: "Correction"
description: "a correction of a fact already written: it names the fact it replaces and why, so a read as of a date before it still shows the old fact and a reader of the stream tells a new fact from a corrected one; the fact corrected no longer stands"
section: concepts
address: /concepts/correction
contract: 0476e35e6e275db5
---

# Correction

a correction of a fact already written: it names the fact it replaces and why, so a read as of a date before it still shows the old fact and a reader of the stream tells a new fact from a corrected one; the fact corrected no longer stands

[figure: Correction is a fact at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | follows |
| key | the fact it replaces |
| store | postgres |
| family | record |



## Fields


| field | type | required | note |
|---|---|---|---|
| `replaces` | `id` | yes | the id of the fact corrected |
| `kind` | `text` | yes | the kind of the fact corrected |
| `reason` | `text` | yes | why it no longer stands, in plain words |
| `rule` | `text` | no | the rule the correction applies, where one does |



## Routes that use it
No route takes or returns Correction directly. The record holds it, and the objects that point at it reach it.


---
title: "Cost"
description: "a cost by kind"
section: concepts
address: /concepts/cost
contract: 0476e35e6e275db5
---

# Cost

a cost by kind

[figure: Cost is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | kernel |



## Fields


| field | type | required | note |
|---|---|---|---|
| `money_outside` | `money` | no |  |
| `model_calls` | `count` | no |  |
| `model_tokens` | `count` | no |  |
| `machine_time` | `duration` | no |  |
| `people_hours` | `duration` | no |  |



## Routes that use it
No route takes or returns Cost directly. The record holds it, and the objects that point at it reach it.


---
title: "CostCeiling"
description: "money a month by kind, and the share at which an alarm is raised"
section: concepts
address: /concepts/costceiling
contract: 0476e35e6e275db5
---

# CostCeiling

money a month by kind, and the share at which an alarm is raised

[figure: CostCeiling is a parameter at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | parameter |
| scope | platform |
| key | the kind |
| store | postgres |
| family | operations |



## Fields


| field | type | required | note |
|---|---|---|---|
| `kind` | `one of model calls \| the store \| rented machines \| sources` | yes |  |
| `ceiling` | `money` | yes |  |
| `alarm_share` | `share` | yes |  |
| `read` | `money` | no | from metered calls and the providers' bills |



## Routes that use it
No route takes or returns CostCeiling directly. The record holds it, and the objects that point at it reach it.


---
title: "Coverage"
description: "what has been read, when and how deep, in three positions, each reading naming its basis"
section: concepts
address: /concepts/coverage
contract: 0476e35e6e275db5
---

# Coverage

what has been read, when and how deep, in three positions, each reading naming its basis

[figure: Coverage is a view at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | none |
| key | a cell, or a scope with a window |
| store | derived |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `cell` | `id` | no |  |
| `scope` | [Predicate](/concepts/predicate) | no |  |
| `window` | [Window](/concepts/window) | yes |  |
| `readings` | [CoverageReading](/concepts/coveragereading) | yes |  |
| `gaps` | [CoverageGap](/concepts/coveragegap) | yes |  |



## Routes that use it
- [`/v1/read/coverage`](/reference/read/coverage) returns it
- [`/v1/read/coverage_by_cell`](/reference/read/coverage_by_cell) returns it


---
title: "CoverageByCellInput"
description: "a source, or a scope with a window"
section: concepts
address: /concepts/coveragebycellinput
contract: 0476e35e6e275db5
---

# CoverageByCellInput

a source, or a scope with a window

[figure: CoverageByCellInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `source` | `id` | no |  |
| `scope` | [Predicate](/concepts/predicate) | no |  |
| `window` | [Window](/concepts/window) | no |  |



## Routes that use it
- [`/v1/read/coverage_by_cell`](/reference/read/coverage_by_cell) takes it as input


---
title: "CoverageGap"
description: "a cell wanted and not covered, with its value and the reason"
section: concepts
address: /concepts/coveragegap
contract: 0476e35e6e275db5
---

# CoverageGap

a cell wanted and not covered, with its value and the reason

[figure: CoverageGap is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `cell` | `id` | yes |  |
| `value` | `share` | yes |  |
| `reason` | `text` | yes |  |
| `what_closes_it` | `text` | yes |  |
| `cost` | [Cost](/concepts/cost) | no |  |



## Routes that use it
No route takes or returns CoverageGap directly. The record holds it, and the objects that point at it reach it.


---
title: "CoverageInput"
description: "a cell, or a scope of entities with a window"
section: concepts
address: /concepts/coverageinput
contract: 0476e35e6e275db5
---

# CoverageInput

a cell, or a scope of entities with a window

[figure: CoverageInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `cell` | `id` | no |  |
| `scope` | [Predicate](/concepts/predicate) | no |  |
| `window` | [Window](/concepts/window) | no |  |



## Routes that use it
- [`/v1/read/coverage`](/reference/read/coverage) takes it as input


---
title: "CoverageReading"
description: "one reading of coverage"
section: concepts
address: /concepts/coveragereading
contract: 0476e35e6e275db5
---

# CoverageReading

one reading of coverage

[figure: CoverageReading is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `position` | `one of measured \| never measured \| withheld` | yes |  |
| `way` | [AccessMethod](/concepts/accessmethod) | no |  |
| `depth` | `text` | no |  |
| `read_at` | `time` | no |  |
| `reason` | `text` | no |  |
| `stand_in_lost` | `text` | no |  |



## Routes that use it
No route takes or returns CoverageReading directly. The record holds it, and the objects that point at it reach it.


---
title: "CrawlScope"
description: "what a scrape may walk: the seeds, the address patterns allowed and denied, the greatest depth and count of pages, whether the sitemap drives discovery, and the pagination rule"
section: concepts
address: /concepts/crawlscope
contract: 0476e35e6e275db5
---

# CrawlScope

what a scrape may walk: the seeds, the address patterns allowed and denied, the greatest depth and count of pages, whether the sitemap drives discovery, and the pagination rule

[figure: CrawlScope is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `seeds` | `[text]` | yes |  |
| `allow_patterns` | `[text]` | yes |  |
| `deny_patterns` | `[text]` | yes |  |
| `max_depth` | `count` | yes |  |
| `max_pages` | `count` | yes |  |
| `use_sitemap` | `bool` | yes |  |
| `pagination` | `text` | no | a selector or a pattern for the next page |



## Routes that use it
No route takes or returns CrawlScope directly. The record holds it, and the objects that point at it reach it.


---
title: "Credential"
description: "a held identity that is a key, a token, a certificate or a signed request; only in the secrets manager, never returned"
section: concepts
address: /concepts/credential
contract: 0476e35e6e275db5
---

# Credential

a held identity that is a key, a token, a certificate or a signed request; only in the secrets manager, never returned

[figure: Credential is a definition at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | follows |
| key |  |
| store | vault |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `platform` | `text` | yes |  |
| `kind` | `one of an API key \| a bearer token \| OAuth 2 \| OAuth 1 \| basic \| a signed request \| a service account \| a client certificate \| an SSH key \| a webhook secret` | yes |  |
| `scopes` | `[text]` | yes | as granted, never as asked |
| `owner` | [Scope](/concepts/scope) | yes | the platform, or a tenant |
| `vault_entry` | `id` | yes |  |
| `last_probe` | [ControlResult](/concepts/controlresult) | no |  |
| `rotation` | `duration` | no | the rule |
| `state` | [Readiness](/concepts/readiness) | yes |  |



## Routes that use it
No route takes or returns Credential directly. The record holds it, and the objects that point at it reach it.


---
title: "CriterionVerdict"
description: "one criterion of a kind of buyer judged for one entity"
section: concepts
address: /concepts/criterionverdict
contract: 0476e35e6e275db5
---

# CriterionVerdict

one criterion of a kind of buyer judged for one entity

[figure: CriterionVerdict is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | people |



## Fields


| field | type | required | note |
|---|---|---|---|
| `criterion` | `text` | yes |  |
| `mode` | `one of required \| disqualifying \| scored \| intent` | yes |  |
| `weight` | `number` | yes |  |
| `probability` | `number` | no | absent when the criterion is missing |
| `basis` | [Basis](/concepts/basis) | yes | measured, or inferred with the model |
| `highlights` | [Highlight](/concepts/highlight) | yes |  |
| `missing` | `text` | no | what the record does not hold |



## Routes that use it
No route takes or returns CriterionVerdict directly. The record holds it, and the objects that point at it reach it.


---
title: "DataGroup"
description: "a named set of units of one kind inside one scope, written as a predicate or a list"
section: concepts
address: /concepts/datagroup
contract: 0476e35e6e275db5
---

# DataGroup

a named set of units of one kind inside one scope, written as a predicate or a list

[figure: DataGroup is a definition at tenant scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | tenant |
| key | its name and its scope |
| store | postgres |
| family | people |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `kind` | [Kind](/concepts/kind) | yes |  |
| `scope` | [Scope](/concepts/scope) | yes |  |
| `members` | [Predicate](/concepts/predicate) | no | or a list |
| `list` | `[id]` | no |  |



## Routes that use it
No route takes or returns DataGroup directly. The record holds it, and the objects that point at it reach it.


---
title: "Deadline"
description: "one unit waiting on a window's end, judged again at that moment by the one evaluator, so a condition made true by nothing arriving still fires"
section: concepts
address: /concepts/deadline
contract: 0476e35e6e275db5
---

# Deadline

one unit waiting on a window's end, judged again at that moment by the one evaluator, so a condition made true by nothing arriving still fires

[figure: Deadline is a work at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | work |
| scope | follows |
| key | the predicate, the unit and the time it falls due |
| store | postgres |
| family | rules_engine |



## Fields


| field | type | required | note |
|---|---|---|---|
| `predicate` | `hash` | yes |  |
| `unit` | `id` | yes | the unit that opened the window |
| `due` | `time` | yes |  |
| `monitor` | `id` | no |  |



## Routes that use it
No route takes or returns Deadline directly. The record holds it, and the objects that point at it reach it.


---
title: "DecideAskInput"
description: "an ask, approved or declined"
section: concepts
address: /concepts/decideaskinput
contract: 0476e35e6e275db5
---

# DecideAskInput

an ask, approved or declined

[figure: DecideAskInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `ask` | `id` | yes |  |
| `decision` | `one of approve \| decline` | yes |  |
| `reason` | `text` | no |  |



## Routes that use it
- [`/v1/act/decide_ask`](/reference/act/decide_ask) takes it as input


---
title: "DecideBrandDesignInput"
description: "a decision on one value of a brand's design system"
section: concepts
address: /concepts/decidebranddesigninput
contract: 0476e35e6e275db5
---

# DecideBrandDesignInput

a decision on one value of a brand's design system

[figure: DecideBrandDesignInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `brand` | `id` | yes |  |
| `path` | `text` | yes |  |
| `decision` | `one of accepted \| declined \| changed` | yes |  |
| `value` | `json` | no | the tenant's own value, when changed |
| `why` | `text` | no |  |



## Routes that use it
- [`/v1/act/decide_brand_design`](/reference/act/decide_brand_design) takes it as input


---
title: "DecideMoveInput"
description: "accept, decline or stop a move"
section: concepts
address: /concepts/decidemoveinput
contract: 0476e35e6e275db5
---

# DecideMoveInput

accept, decline or stop a move

[figure: DecideMoveInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `move` | `id` | yes |  |
| `decision` | `one of accept \| decline \| stop` | yes |  |
| `reason` | `text` | no |  |



## Routes that use it
- [`/v1/act/decide_move`](/reference/act/decide_move) takes it as input


---
title: "DeclinedCell"
description: "a cell declined with its reason"
section: concepts
address: /concepts/declinedcell
contract: 0476e35e6e275db5
---

# DeclinedCell

a cell declined with its reason

[figure: DeclinedCell is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `cell` | `id` | yes |  |
| `reason` | `text` | yes |  |



## Routes that use it
No route takes or returns DeclinedCell directly. The record holds it, and the objects that point at it reach it.


---
title: "Deepening"
description: "depth asked for one observation, with the reason it stopped"
section: concepts
address: /concepts/deepening
contract: 0476e35e6e275db5
---

# Deepening

depth asked for one observation, with the reason it stopped

[figure: Deepening is a work at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | work |
| scope | follows |
| key | the observation |
| store | postgres |
| family | record |



## Fields


| field | type | required | note |
|---|---|---|---|
| `observation` | `id` | yes |  |
| `depth_asked` | `one of fetch \| embed \| both` | yes |  |
| `asked_by` | `id` | yes | a definition, a match or a person |
| `why_stopped` | `text` | no |  |



## Routes that use it
- [`/v1/act/deepen`](/reference/act/deepen) returns it


---
title: "DeepenInput"
description: "an observation and the depth asked"
section: concepts
address: /concepts/deepeninput
contract: 0476e35e6e275db5
---

# DeepenInput

an observation and the depth asked

[figure: DeepenInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `observation` | `id` | yes |  |
| `depth` | `one of fetch \| embed \| both` | yes |  |
| `asked_by` | [UnitRef](/concepts/unitref) | yes |  |



## Routes that use it
- [`/v1/act/deepen`](/reference/act/deepen) takes it as input


---
title: "DefinitionBase"
description: "what every definition carries beyond the unit"
section: concepts
address: /concepts/definitionbase
contract: 0476e35e6e275db5
---

# DefinitionBase

what every definition carries beyond the unit

[figure: DefinitionBase is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | carried by every definition |
| store | none |
| family | kernel |



## Fields


| field | type | required | note |
|---|---|---|---|
| `version` | `count` | yes | changed only by a new version; an old version stays what it was |
| `content_hash` | `hash` | yes |  |
| `state` | [Readiness](/concepts/readiness) | yes | ready, or not ready with its reason |
| `author` | [Caller](/concepts/caller) | yes |  |
| `original` | `id` | no | for a copy of a platform original: the original |
| `copied_from_version` | `count` | no | and the version it was copied from |



## Routes that use it
No route takes or returns DefinitionBase directly. The record holds it, and the objects that point at it reach it.


---
title: "DelegateInput"
description: "something said to the agent"
section: concepts
address: /concepts/delegateinput
contract: 0476e35e6e275db5
---

# DelegateInput

something said to the agent

[figure: DelegateInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `words` | `text` | yes |  |
| `about` | [UnitRef](/concepts/unitref) | no |  |
| `strategy` | `id` | no |  |



## Routes that use it
- [`/v1/harness/delegate`](/reference/harness/delegate) takes it as input


---
title: "DemandCell"
description: "one demand cell however many definitions arm it; no tenant and no strategy in its key, only its plane"
section: concepts
address: /concepts/demandcell
contract: 0476e35e6e275db5
---

# DemandCell

one demand cell however many definitions arm it; no tenant and no strategy in its key, only its plane

[figure: DemandCell is a work at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | work |
| scope | follows |
| key | a source, a scope of entities, a bucket of time and a group of fields |
| store | postgres |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `source` | [Source](/concepts/source) | yes |  |
| `entities` | [Predicate](/concepts/predicate) | yes |  |
| `bucket` | [Window](/concepts/window) | yes |  |
| `fields` | `[text]` | yes |  |
| `plane` | [Plane](/concepts/plane) | yes |  |
| `value` | `share` | yes |  |
| `armings` | `[id]` | yes |  |



## Routes that use it
- [`/v1/act/raise_need`](/reference/act/raise_need) returns it


---
title: "DemandStatement"
description: "the one crossing out to the acquisition system"
section: concepts
address: /concepts/demandstatement
contract: 0476e35e6e275db5
---

# DemandStatement

the one crossing out to the acquisition system

[figure: DemandStatement is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `source` | [Source](/concepts/source) | yes |  |
| `way` | [AccessMethod](/concepts/accessmethod) | yes |  |
| `plane` | [Plane](/concepts/plane) | yes |  |
| `cadence` | `duration` | yes | a time and never zero |
| `term` | [Window](/concepts/window) | yes |  |
| `contributions` | [Contribution](/concepts/contribution) | yes | the count must agree with the list |



## Routes that use it
No route takes or returns DemandStatement directly. The record holds it, and the objects that point at it reach it.


---
title: "DenyHost"
description: "a host whose addresses a capture turns away, the one list that does: a tracker, an advertising pixel or a malicious host, named by a person, never a guess; every other address a walk discovers is queued as a capture of its own, because nothing a capture reaches is out of scope"
section: concepts
address: /concepts/denyhost
contract: 0476e35e6e275db5
---

# DenyHost

a host whose addresses a capture turns away, the one list that does: a tracker, an advertising pixel or a malicious host, named by a person, never a guess; every other address a walk discovers is queued as a capture of its own, because nothing a capture reaches is out of scope

[figure: DenyHost is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | its host |
| store | postgres |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes | the host, and every host under it |
| `why` | `one of a tracker \| an advertising pixel \| a malicious host` | yes |  |
| `named_by` | `text` | yes | who named it and when |
| `state` | [Readiness](/concepts/readiness) | yes |  |



## Routes that use it
No route takes or returns DenyHost directly. The record holds it, and the objects that point at it reach it.


---
title: "DerivedGraph"
description: "weighted connections computed from the record's connections by a named recipe over a window; rebuilt, never edited"
section: concepts
address: /concepts/derivedgraph
contract: 0476e35e6e275db5
---

# DerivedGraph

weighted connections computed from the record's connections by a named recipe over a window; rebuilt, never edited

[figure: DerivedGraph is a definition at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | follows |
| key | the recipe and the window |
| store | postgres+lake |
| family | models |



## Fields


| field | type | required | note |
|---|---|---|---|
| `recipe` | `text` | yes |  |
| `recipe_version` | `text` | yes |  |
| `window` | [Window](/concepts/window) | yes |  |
| `population` | [PopulationStatement](/concepts/populationstatement) | yes |  |
| `validity` | `share` | no |  |
| `completeness` | `share` | no |  |
| `coverage` | `share` | no |  |
| `hub_cap` | `count` | yes | what one very connected entity can decide |
| `rebuild` | `id` | no | the work that rebuilt it |



## Routes that use it
No route takes or returns DerivedGraph directly. The record holds it, and the objects that point at it reach it.


---
title: "DesignAxis"
description: "one axis a design system varies along, with its options; a coordinate names one option of every axis; a new axis is a row"
section: concepts
address: /concepts/designaxis
contract: 0476e35e6e275db5
---

# DesignAxis

one axis a design system varies along, with its options; a coordinate names one option of every axis; a new axis is a row

[figure: DesignAxis is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | its name |
| store | postgres |
| family | interfaces |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `what` | `text` | yes |  |
| `options` | `[text]` | yes |  |
| `default` | `text` | yes |  |



## Routes that use it
No route takes or returns DesignAxis directly. The record holds it, and the objects that point at it reach it.


---
title: "DesignOfAnEffect"
description: "one design that reads an effect against the tide: what it needs, what it assumes, when it is used, and what makes its answer cannot tell; the five the model places on the graph, each a row"
section: concepts
address: /concepts/designofaneffect
contract: 0476e35e6e275db5
---

# DesignOfAnEffect

one design that reads an effect against the tide: what it needs, what it assumes, when it is used, and what makes its answer cannot tell; the five the model places on the graph, each a row

[figure: DesignOfAnEffect is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | its name |
| store | postgres |
| family | strategy |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `order` | `count` | yes | the order of what is built first |
| `needs` | `text` | yes |  |
| `assumes` | `text` | yes |  |
| `when` | `text` | yes |  |
| `estimand` | `text` | yes |  |
| `cannot_tell_when` | `text` | yes |  |
| `reference` | `text` | yes |  |



## Routes that use it
No route takes or returns DesignOfAnEffect directly. The record holds it, and the objects that point at it reach it.


---
title: "DesignSystem"
description: "the tokens, the two type systems, the three tonal levels, the closed glyph set, the motion rules, the component library"
section: concepts
address: /concepts/designsystem
contract: 0476e35e6e275db5
---

# DesignSystem

the tokens, the two type systems, the three tonal levels, the closed glyph set, the motion rules, the component library

[figure: DesignSystem is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | its version |
| store | postgres |
| family | interfaces |



## Fields


| field | type | required | note |
|---|---|---|---|
| `version` | `count` | yes |  |
| `tokens` | `json` | yes |  |
| `glyphs` | `[text]` | yes | closed; no emoji |
| `components` | `[text]` | yes |  |



## Routes that use it
No route takes or returns DesignSystem directly. The record holds it, and the objects that point at it reach it.


---
title: "DocClaim"
description: "one statement a page makes about the platform, typed live or target against the served contract"
section: concepts
address: /concepts/docclaim
contract: 0476e35e6e275db5
---

# DocClaim

one statement a page makes about the platform, typed live or target against the served contract

[figure: DocClaim is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | documentation |



## Fields


| field | type | required | note |
|---|---|---|---|
| `text` | `text` | yes |  |
| `state` | `one of live \| target` | yes |  |
| `cites` | `text` | yes | a route or a tool id |
| `checked_at` | `time` | yes |  |



## Routes that use it
No route takes or returns DocClaim directly. The record holds it, and the objects that point at it reach it.


---
title: "DocExample"
description: "one example on a page, rendered in each language from one source and validated against its type"
section: concepts
address: /concepts/docexample
contract: 0476e35e6e275db5
---

# DocExample

one example on a page, rendered in each language from one source and validated against its type

[figure: DocExample is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | documentation |



## Fields


| field | type | required | note |
|---|---|---|---|
| `language` | `one of curl \| typescript \| python \| rust \| json \| sql` | yes |  |
| `code` | `text` | yes |  |
| `validates_against` | `text` | yes | a type of the register |



## Routes that use it
No route takes or returns DocExample directly. The record holds it, and the objects that point at it reach it.


---
title: "DocIsland"
description: "one interactive island of the site: what it does, the SDK call it makes and whether it needs a key"
section: concepts
address: /concepts/docisland
contract: 0476e35e6e275db5
---

# DocIsland

one interactive island of the site: what it does, the SDK call it makes and whether it needs a key

[figure: DocIsland is a definition at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | platform |
| key | its name |
| store | postgres |
| family | documentation |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `one of api-explorer \| query-playground \| preview-widget \| search \| theme-and-density` | yes |  |
| `does` | `text` | yes |  |
| `sdk_call` | `text` | no |  |
| `needs_key` | `bool` | yes |  |



## Routes that use it
No route takes or returns DocIsland directly. The record holds it, and the objects that point at it reach it.


---
title: "DocPage"
description: "one page of the documentation site: where it comes from, its claims, its examples and its Markdown twin"
section: concepts
address: /concepts/docpage
contract: 0476e35e6e275db5
---

# DocPage

one page of the documentation site: where it comes from, its claims, its examples and its Markdown twin

[figure: DocPage is a definition at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | platform |
| key | its address |
| store | postgres |
| family | documentation |



## Fields


| field | type | required | note |
|---|---|---|---|
| `address` | `text` | yes |  |
| `title` | `text` | yes |  |
| `description` | `text` | yes |  |
| `section` | [DocSection](/concepts/docsection) | yes |  |
| `source` | `one of hand-written \| from the contract \| from a register` | yes |  |
| `generated_from` | `text` | no | the document or the register a generated page is built from |
| `claims` | [DocClaim](/concepts/docclaim) | yes |  |
| `examples` | [DocExample](/concepts/docexample) | yes |  |
| `twin` | `text` | yes | the address with .md appended |
| `structured_data` | `json` | yes | JSON-LD |
| `updated` | `time` | yes |  |
| `contract_hash` | `hash` | yes |  |



## Routes that use it
No route takes or returns DocPage directly. The record holds it, and the objects that point at it reach it.


---
title: "DocSection"
description: "one section of the documentation site: its purpose, its order and its pages"
section: concepts
address: /concepts/docsection
contract: 0476e35e6e275db5
---

# DocSection

one section of the documentation site: its purpose, its order and its pages

[figure: DocSection is a definition at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | platform |
| key | its slug |
| store | postgres |
| family | documentation |



## Fields


| field | type | required | note |
|---|---|---|---|
| `slug` | `text` | yes |  |
| `title` | `text` | yes |  |
| `order` | `count` | yes |  |
| `purpose` | `one of start \| install \| guides \| concepts \| reference \| for-models \| changelog` | yes |  |
| `pages` | `[id]` | yes | the pages of the section, by address |



## Routes that use it
No route takes or returns DocSection directly. The record holds it, and the objects that point at it reach it.


---
title: "Document"
description: "a document built from the record: its kind, its recipe, its versions"
section: concepts
address: /concepts/document
contract: 0476e35e6e275db5
---

# Document

a document built from the record: its kind, its recipe, its versions

[figure: Document is a definition at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | follows |
| key | its kind and its recipe's version |
| store | postgres |
| family | documents |



## Fields


| field | type | required | note |
|---|---|---|---|
| `kind` | `one of a report \| a brief \| a call set \| a set of options \| a workbench page \| a story in a frame \| a page of the documentation \| an estimator page` | yes |  |
| `recipe` | [Recipe](/concepts/recipe) | yes |  |
| `versions` | `[id]` | yes | its builds |
| `visibility` | `one of private \| the tenant \| published` | yes |  |



## Routes that use it
No route takes or returns Document directly. The record holds it, and the objects that point at it reach it.


---
title: "DocumentChangesInput"
description: "two versions of one document"
section: concepts
address: /concepts/documentchangesinput
contract: 0476e35e6e275db5
---

# DocumentChangesInput

two versions of one document

[figure: DocumentChangesInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `document` | `id` | yes |  |
| `first` | `count` | yes |  |
| `second` | `count` | yes |  |



## Routes that use it
- [`/v1/read/document_changes`](/reference/read/document_changes) takes it as input


---
title: "DocumentInput"
description: "the document and the version"
section: concepts
address: /concepts/documentinput
contract: 0476e35e6e275db5
---

# DocumentInput

the document and the version

[figure: DocumentInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `document` | `id` | yes |  |
| `version` | `count` | no |  |



## Routes that use it
- [`/v1/read/document`](/reference/read/document) takes it as input


---
title: "DownloadControlInput"
description: "pause, resume or cancel one download or a set"
section: concepts
address: /concepts/downloadcontrolinput
contract: 0476e35e6e275db5
---

# DownloadControlInput

pause, resume or cancel one download or a set

[figure: DownloadControlInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `job` | `id` | no |  |
| `set` | `id` | no |  |
| `control` | `one of pause \| resume \| cancel` | yes |  |



## Routes that use it
- [`/v1/work/download_set_control`](/reference/work/download_set_control) takes it as input


---
title: "DownloadInput"
description: "a file or a document to download into the workspace"
section: concepts
address: /concepts/downloadinput
contract: 0476e35e6e275db5
---

# DownloadInput

a file or a document to download into the workspace

[figure: DownloadInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `pointer` | `id` | yes |  |
| `into` | `text` | no |  |



## Routes that use it
- [`/v1/files/download`](/reference/files/download) takes it as input


---
title: "DownloadJob"
description: "one file of a download set through the download manager: resumable by byte range, pausable, bounded by residency, landing in bronze or the person's workspace"
section: concepts
address: /concepts/downloadjob
contract: 0476e35e6e275db5
---

# DownloadJob

one file of a download set through the download manager: resumable by byte range, pausable, bounded by residency, landing in bronze or the person's workspace

[figure: DownloadJob is a work at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | work |
| scope | follows |
| key | the address and the caller |
| store | postgres |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `address` | `text` | yes |  |
| `set` | `id` | yes | the download set it belongs to |
| `identity` | `id` | no | the page's session or a held identity |
| `filter` | [ResourceFilter](/concepts/resourcefilter) | yes |  |
| `bytes_expected` | `count` | no |  |
| `bytes_done` | `count` | yes |  |
| `destination` | `one of bronze \| the workspace` | yes |  |
| `artefact_hash` | `hash` | no |  |
| `failure` | [FailureClass](/concepts/failureclass) | no |  |



## Routes that use it
No route takes or returns DownloadJob directly. The record holds it, and the objects that point at it reach it.


---
title: "DownloadSetInput"
description: "one or many addresses to download through the download manager, from a page or from anywhere"
section: concepts
address: /concepts/downloadsetinput
contract: 0476e35e6e275db5
---

# DownloadSetInput

one or many addresses to download through the download manager, from a page or from anywhere

[figure: DownloadSetInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `addresses` | `[text]` | yes |  |
| `session` | `id` | no | the browsing session whose cookies serve |
| `identity` | `id` | no |  |
| `filter` | [ResourceFilter](/concepts/resourcefilter) | yes |  |
| `destination` | `one of bronze \| the workspace` | yes |  |



## Routes that use it
- [`/v1/work/download_set`](/reference/work/download_set) takes it as input


---
title: "Draft"
description: "a thing being made in the definitions studio: the rows it is made from, its preview, its proofs"
section: concepts
address: /concepts/draft
contract: 0476e35e6e275db5
---

# Draft

a thing being made in the definitions studio: the rows it is made from, its preview, its proofs

[figure: Draft is a work at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | work |
| scope | follows |
| key | the kind, the designer's input and the version |
| store | postgres |
| family | studio |



## Fields


| field | type | required | note |
|---|---|---|---|
| `kind` | [Kind](/concepts/kind) | yes |  |
| `input` | `json` | yes |  |
| `version` | `count` | yes |  |
| `rows` | `[id]` | yes |  |
| `preview` | [PreviewAnswer](/concepts/previewanswer) | no |  |
| `proofs` | `[id]` | yes |  |
| `becomes` | `id` | no | the register row |



## Routes that use it
No route takes or returns Draft directly. The record holds it, and the objects that point at it reach it.


---
title: "DriverNode"
description: "one node of a value driver tree: a leaf that a party states, or a formula over its children"
section: concepts
address: /concepts/drivernode
contract: 0476e35e6e275db5
---

# DriverNode

one node of a value driver tree: a leaf that a party states, or a formula over its children

[figure: DriverNode is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | one node of a driver tree |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `driver` | [KindOfMeasure](/concepts/kindofmeasure) | yes | the value driver this node produces, a kind of measure of the economics family |
| `operator` | `one of leaf \| add \| subtract \| multiply \| divide \| minimum \| maximum \| constant \| share of \| per period \| clamp` | yes | leaf for a stated, read or benchmarked input; the rest are the closed operators the one evaluator computes |
| `children` | [DriverNode](/concepts/drivernode) | no | the operands, in order; empty for a leaf |
| `constant` | `json` | no | the value of a constant node, with the dimension below |
| `dimension` | `text` | yes | the dimension the node produces, which the evaluator checks follows from its children |
| `stated_by` | `one of the buyer \| a benchmark \| the record \| a formula` | yes | who supplies the number: the buyer states it, a benchmark carries it, the record holds it, or the formula computes it |
| `question` | `text` | no | for a driver the buyer states: the question in the buyer's own words |
| `bounds` | [Interval](/concepts/interval) | no | the floor and the ceiling a stated value may not cross |



## Routes that use it
No route takes or returns DriverNode directly. The record holds it, and the objects that point at it reach it.


---
title: "DryRunAnswer"
description: "what it would do, and what the inverse would be"
section: concepts
address: /concepts/dryrunanswer
contract: 0476e35e6e275db5
---

# DryRunAnswer

what it would do, and what the inverse would be

[figure: DryRunAnswer is a view at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `would_do` | `text` | yes |  |
| `inverse` | `text` | yes |  |
| `arguments` | [ActionArgument](/concepts/actionargument) | yes |  |
| `allowed` | [PermissionAnswer](/concepts/permissionanswer) | yes |  |



## Routes that use it
- [`/v1/act/dry_run`](/reference/act/dry_run) returns it


---
title: "DryRunInput"
description: "an action to dry run"
section: concepts
address: /concepts/dryruninput
contract: 0476e35e6e275db5
---

# DryRunInput

an action to dry run

[figure: DryRunInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `action` | `id` | yes |  |



## Routes that use it
- [`/v1/act/dry_run`](/reference/act/dry_run) takes it as input


---
title: "EconomicReading"
description: "a number about a buyer profile that is not a count of members, in exactly one of three positions: a summary measured, an estimate with its interval, or a parameter stipulated"
section: concepts
address: /concepts/economicreading
contract: 0476e35e6e275db5
---

# EconomicReading

a number about a buyer profile that is not a count of members, in exactly one of three positions: a summary measured, an estimate with its interval, or a parameter stipulated

[figure: EconomicReading is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `measure` | [KindOfMeasure](/concepts/kindofmeasure) | yes |  |
| `value` | [NumberInPosition](/concepts/numberinposition) | yes | in exactly one of the three positions |



## Routes that use it
No route takes or returns EconomicReading directly. The record holds it, and the objects that point at it reach it.


---
title: "Effect"
description: "the change where it ran against the change where it did not, with an interval; or withheld with what would settle it"
section: concepts
address: /concepts/effect
contract: 0476e35e6e275db5
---

# Effect

the change where it ran against the change where it did not, with an interval; or withheld with what would settle it

[figure: Effect is a fact at strategy scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | strategy |
| key | the move and the window |
| store | postgres+lake |
| family | strategy |



## Fields


| field | type | required | note |
|---|---|---|---|
| `move` | `id` | yes |  |
| `design` | [DesignOfAnEffect](/concepts/designofaneffect) | yes | the design that read it, fixed before the window opened |
| `change` | [Interval](/concepts/interval) | no |  |
| `holdout_change` | [Interval](/concepts/interval) | no |  |
| `effect` | [Interval](/concepts/interval) | no |  |
| `floor` | `share` | yes |  |
| `withheld` | `bool` | yes |  |
| `what_would_settle_it` | `text` | no |  |
| `forecast` | `id` | yes |  |
| `assignments` | `[id]` | yes |  |
| `read_at` | `time` | yes |  |
| `verdict` | `one of held \| missed \| cannot tell` | no | the forecast's verdict: held when the effect's lower bound clears the number that proves it wrong, missed when its upper bound does not, cannot tell between |
| `share_above_zero` | `share` | no | the share of the effect's interval that lies above zero; absent when the effect is withheld |
| `cause_claimed` | `bool` | yes | true when the share above zero reaches the bar of the row that names the share below which no cause is claimed, so the impact is raised; false leaves the effect measured and raises no impact |



## Routes that use it
- [`/v1/read/effect`](/reference/read/effect) returns it


---
title: "EffectInput"
description: "a move and the window"
section: concepts
address: /concepts/effectinput
contract: 0476e35e6e275db5
---

# EffectInput

a move and the window

[figure: EffectInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `move` | `id` | yes |  |
| `window` | [Window](/concepts/window) | no |  |



## Routes that use it
- [`/v1/read/effect`](/reference/read/effect) takes it as input


---
title: "EgressReading"
description: "bytes one connector sent and received through the relay on one day"
section: concepts
address: /concepts/egressreading
contract: 0476e35e6e275db5
---

# EgressReading

bytes one connector sent and received through the relay on one day

[figure: EgressReading is a fact at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | platform |
| key | the connector and the day |
| store | postgres+lake |
| family | network |



## Fields


| field | type | required | note |
|---|---|---|---|
| `connector` | [Source](/concepts/source) | yes | the connector's registry row |
| `day` | `date` | yes |  |
| `bytes_out` | `bytes` | yes |  |
| `bytes_in` | `bytes` | yes |  |
| `limit_reached_at` | `time` | no |  |



## Routes that use it
No route takes or returns EgressReading directly. The record holds it, and the objects that point at it reach it.


---
title: "EgressRelay"
description: "the outbound relay every connector's traffic leaves through, with bytes accounted per connector against a limit"
section: concepts
address: /concepts/egressrelay
contract: 0476e35e6e275db5
---

# EgressRelay

the outbound relay every connector's traffic leaves through, with bytes accounted per connector against a limit

[figure: EgressRelay is a definition at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | platform |
| key | its name |
| store | postgres |
| family | network |



## Fields


| field | type | required | note |
|---|---|---|---|
| `address` | `address` | yes |  |
| `bytes_limit_per_connector_per_day` | `bytes` | yes | a parameter of the machinery family |
| `accounting` | [EgressReading](/concepts/egressreading) | yes |  |



## Routes that use it
No route takes or returns EgressRelay directly. The record holds it, and the objects that point at it reach it.


---
title: "EndpointHolder"
description: "the process that serves the durable engine's endpoint on this machine, written beside the stack: its process id, the hash of the binary it runs, its release, its port and when it started; a newer release takes the endpoint over from an older one, the same release shares it, and an older one never takes it back"
section: concepts
address: /concepts/endpointholder
contract: 0476e35e6e275db5
---

# EndpointHolder

the process that serves the durable engine's endpoint on this machine, written beside the stack: its process id, the hash of the binary it runs, its release, its port and when it started; a newer release takes the endpoint over from an older one, the same release shares it, and an older one never takes it back

[figure: EndpointHolder is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `pid` | `count` | yes |  |
| `binary_hash` | `hash` | yes |  |
| `started_at` | `time` | yes |  |
| `port` | `count` | yes |  |
| `release` | [ReleaseStamp](/concepts/releasestamp) | no | absent on a binary built before releases were stamped, which every stamped release reads as older |



## Routes that use it
No route takes or returns EndpointHolder directly. The record holds it, and the objects that point at it reach it.


---
title: "EngineExtension"
description: "one extension of the query engine, pinned by version and hash as a row of the release, shipped with it and never fetched at run time"
section: concepts
address: /concepts/engineextension
contract: 0476e35e6e275db5
---

# EngineExtension

one extension of the query engine, pinned by version and hash as a row of the release, shipped with it and never fetched at run time

[figure: EngineExtension is a definition at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | platform |
| key | its name and the engine's version |
| store | postgres |
| family | operations |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes | lakehouse, database, spatial |
| `engine_version` | `text` | yes |  |
| `version` | `text` | yes |  |
| `hash` | `hash` | yes |  |
| `release` | `id` | yes |  |
| `state` | [Readiness](/concepts/readiness) | yes | not ready when the shipped file's hash differs |



## Routes that use it
No route takes or returns EngineExtension directly. The record holds it, and the objects that point at it reach it.


---
title: "Entity"
description: "a thing of the market that lasts"
section: concepts
address: /concepts/entity
contract: 0476e35e6e275db5
---

# Entity

a thing of the market that lasts

[figure: Entity is a entity at shared scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | entity |
| scope | shared |
| key | decided; never made from an attribute |
| store | postgres |
| family | identity |



## Fields


| field | type | required | note |
|---|---|---|---|
| `kind` | [KindOfEntity](/concepts/kindofentity) | yes |  |
| `name` | `text` | yes | the display name, itself a claim |
| `identifiers` | [Identifier](/concepts/identifier) | yes | every key it ever had |
| `plane` | [Plane](/concepts/plane) | yes | kept once, or a tenant's |



## Routes that use it
No route takes or returns Entity directly. The record holds it, and the objects that point at it reach it.


---
title: "EntityBase"
description: "what every entity carries beyond the unit"
section: concepts
address: /concepts/entitybase
contract: 0476e35e6e275db5
---

# EntityBase

what every entity carries beyond the unit

[figure: EntityBase is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | carried by every entity |
| store | none |
| family | kernel |



## Fields


| field | type | required | note |
|---|---|---|---|
| `state` | `one of unproved \| resolved` | yes |  |
| `resolver_version` | `text` | no | absent for a kind that is the same by construction |
| `evidence` | `[id]` | no | the identity decisions it was resolved under |



## Routes that use it
No route takes or returns EntityBase directly. The record holds it, and the objects that point at it reach it.


---
title: "EntityInput"
description: "an entity, and the two dates"
section: concepts
address: /concepts/entityinput
contract: 0476e35e6e275db5
---

# EntityInput

an entity, and the two dates

[figure: EntityInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `entity` | `id` | yes |  |



## Routes that use it
- [`/v1/read/entity`](/reference/read/entity) takes it as input


---
title: "EntitySurface"
description: "every identifier it ever had, every account, everything it published, every thread, community and gathering, and every connection"
section: concepts
address: /concepts/entitysurface
contract: 0476e35e6e275db5
---

# EntitySurface

every identifier it ever had, every account, everything it published, every thread, community and gathering, and every connection

[figure: EntitySurface is a view at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `entity` | [Entity](/concepts/entity) | yes |  |
| `identifiers` | [Identifier](/concepts/identifier) | yes |  |
| `accounts` | `[id]` | yes |  |
| `published` | `[id]` | yes |  |
| `communities` | `[id]` | yes |  |
| `connections` | [Connection](/concepts/connection) | yes |  |
| `claims` | [Claim](/concepts/claim) | yes |  |
| `hypotheses` | `[id]` | yes |  |



## Routes that use it
- [`/v1/read/entity`](/reference/read/entity) returns it


---
title: "Envelope"
description: "the shared envelope every event and every crossing carries"
section: concepts
address: /concepts/envelope
contract: 0476e35e6e275db5
---

# Envelope

the shared envelope every event and every crossing carries

[figure: Envelope is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | kernel |



## Fields


| field | type | required | note |
|---|---|---|---|
| `id` | `id` | yes |  |
| `kind` | `text` | yes |  |
| `version_of_shape` | `count` | yes |  |
| `at` | `time` | yes |  |
| `plane` | `one of tenant plane \| work plane \| shared \| tenant` | yes |  |
| `trace` | `id` | yes |  |
| `payload` | `json` | yes | the serialisation of the owning type the kind names |



## Routes that use it
No route takes or returns Envelope directly. The record holds it, and the objects that point at it reach it.


---
title: "ErasePersonInput"
description: "the person to erase, and the second administrator's verification"
section: concepts
address: /concepts/erasepersoninput
contract: 0476e35e6e275db5
---

# ErasePersonInput

the person to erase, and the second administrator's verification

[figure: ErasePersonInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `person` | `id` | yes |  |
| `verified_by` | `id` | yes |  |



## Routes that use it
- [`/v1/act/erase_person`](/reference/act/erase_person) takes it as input


---
title: "ErasureReceipt"
description: "the receipt of an erasure: who asked, who verified, when it ran, what it covered in counts, its hash; never what was erased"
section: concepts
address: /concepts/erasurereceipt
contract: 0476e35e6e275db5
---

# ErasureReceipt

the receipt of an erasure: who asked, who verified, when it ran, what it covered in counts, its hash; never what was erased

[figure: ErasureReceipt is a fact at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | platform |
| key | the tenant and the time |
| store | postgres |
| family | people |



## Fields


| field | type | required | note |
|---|---|---|---|
| `tenant` | `id` | yes |  |
| `subject` | `id` | no | a person, for a person's erasure |
| `asked_by` | `id` | yes |  |
| `verified_by` | `id` | yes |  |
| `ran_at` | `time` | yes |  |
| `counts` | `json` | yes | by kind of row |
| `hash` | `hash` | yes |  |



## Routes that use it
- [`/v1/act/erase_person`](/reference/act/erase_person) returns it


---
title: "Estimate"
description: "a point with its interval, the balance of evidence, and how familiar the case is; or withheld"
section: concepts
address: /concepts/estimate
contract: 0476e35e6e275db5
---

# Estimate

a point with its interval, the balance of evidence, and how familiar the case is; or withheld

[figure: Estimate is a fact at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | follows |
| key | the model, the version and the case |
| store | postgres+lake |
| family | models |



## Fields


| field | type | required | note |
|---|---|---|---|
| `model` | [Model](/concepts/model) | yes |  |
| `case` | `id` | yes |  |
| `value` | [Interval](/concepts/interval) | no |  |
| `evidence` | [EvidenceRef](/concepts/evidenceref) | yes | each supporting or against |
| `familiarity` | `share` | yes |  |
| `withheld` | `bool` | yes |  |
| `reason` | `text` | no |  |



## Routes that use it
- [`/v1/read/estimate`](/reference/read/estimate) returns it


---
title: "EstimateInput"
description: "an estimator and the case"
section: concepts
address: /concepts/estimateinput
contract: 0476e35e6e275db5
---

# EstimateInput

an estimator and the case

[figure: EstimateInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `model` | [Model](/concepts/model) | yes |  |
| `case` | [UnitRef](/concepts/unitref) | yes |  |



## Routes that use it
- [`/v1/read/estimate`](/reference/read/estimate) takes it as input


---
title: "EstimateReturnInput"
description: "the buyer, the offering or tier, the numbers stated for this ask, and whether to simulate"
section: concepts
address: /concepts/estimatereturninput
contract: 0476e35e6e275db5
---

# EstimateReturnInput

the buyer, the offering or tier, the numbers stated for this ask, and whether to simulate

[figure: EstimateReturnInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | one ask of an estimate |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `buyer` | [UnitRef](/concepts/unitref) | yes |  |
| `offering` | `id` | no |  |
| `tier` | `text` | no |  |
| `stated` | `{text:json}` | no | driver name to value, each written as a stated number before the estimate reads it |
| `simulate` | `bool` | yes |  |



## Routes that use it
- [`/v1/economics/estimate`](/reference/economics/estimate) takes it as input


---
title: "Event"
description: "one change of state, written in the same transaction as the change"
section: concepts
address: /concepts/event
contract: 0476e35e6e275db5
---

# Event

one change of state, written in the same transaction as the change

[figure: Event is a fact at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | follows |
| key | the flow, the unit and the moment |
| store | log |
| family | kernel |



## Fields


| field | type | required | note |
|---|---|---|---|
| `flow` | [Flow](/concepts/flow) | yes |  |
| `unit` | `id` | yes |  |
| `at` | `time` | yes |  |
| `by` | [Caller](/concepts/caller) | yes |  |
| `plane` | `one of tenant plane \| work plane` | yes |  |
| `from_place` | `text` | no |  |
| `to_place` | `text` | no |  |
| `outcome` | `text` | yes |  |
| `reason` | `text` | no | typed, from the flow's row |
| `run` | `id` | yes |  |
| `correction_of` | `id` | no | an event that corrects an earlier one names it |



## Routes that use it
- [`/v1/act/correct`](/reference/act/correct) returns it


---
title: "EventCursor"
description: "the position in the event log a client has rendered to; a reconnecting client sends it and receives every event after it"
section: concepts
address: /concepts/eventcursor
contract: 0476e35e6e275db5
---

# EventCursor

the position in the event log a client has rendered to; a reconnecting client sends it and receives every event after it

[figure: EventCursor is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `thread` | `id` | yes |  |
| `position` | `count` | yes |  |



## Routes that use it
No route takes or returns EventCursor directly. The record holds it, and the objects that point at it reach it.


---
title: "EvidenceRef"
description: "one piece of evidence: a unit of any kind, with its basis and its weight"
section: concepts
address: /concepts/evidenceref
contract: 0476e35e6e275db5
---

# EvidenceRef

one piece of evidence: a unit of any kind, with its basis and its weight

[figure: EvidenceRef is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | kernel |



## Fields


| field | type | required | note |
|---|---|---|---|
| `unit` | `id` | yes | a fact, an observation, a preview or a reading |
| `basis` | [Basis](/concepts/basis) | yes | measured or inferred |
| `weight` | `share` | no |  |
| `note` | `text` | no |  |
| `partition` | `id` | no | the catalogue entry of the partition that holds the unit, written at accept; required when the unit is a fact of the lakehouse |



## Routes that use it
No route takes or returns EvidenceRef directly. The record holds it, and the objects that point at it reach it.


---
title: "Explanation"
description: "why an entity is a lead, written by a model from the highlighted evidence alone, citing each span"
section: concepts
address: /concepts/explanation
contract: 0476e35e6e275db5
---

# Explanation

why an entity is a lead, written by a model from the highlighted evidence alone, citing each span

[figure: Explanation is a fact at tenant scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | tenant |
| key | the lead and the model |
| store | postgres |
| family | people |



## Fields


| field | type | required | note |
|---|---|---|---|
| `lead` | `id` | yes |  |
| `text` | `text` | yes |  |
| `model` | `text` | yes | the model id |
| `cites` | [Highlight](/concepts/highlight) | yes |  |



## Routes that use it
No route takes or returns Explanation directly. The record holds it, and the objects that point at it reach it.


---
title: "ExportReceipt"
description: "the receipt of a tenant's or a person's export: who asked, when it ran, every file with its hash and its count"
section: concepts
address: /concepts/exportreceipt
contract: 0476e35e6e275db5
---

# ExportReceipt

the receipt of a tenant's or a person's export: who asked, when it ran, every file with its hash and its count

[figure: ExportReceipt is a fact at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | platform |
| key | the tenant and the time |
| store | postgres |
| family | people |



## Fields


| field | type | required | note |
|---|---|---|---|
| `tenant` | `id` | yes |  |
| `subject` | `id` | no | a person, for a person's export |
| `asked_by` | `id` | yes |  |
| `ran_at` | `time` | yes |  |
| `files` | `[json]` | yes | path, hash, rows |
| `hash` | `hash` | yes |  |



## Routes that use it
- [`/v1/act/export_tenant`](/reference/act/export_tenant) returns it


---
title: "ExtensionSession"
description: "the extension's sign-in: the person, the tenant, the token's expiry, the transport in use and the contract hash the server reports"
section: concepts
address: /concepts/extensionsession
contract: 0476e35e6e275db5
---

# ExtensionSession

the extension's sign-in: the person, the tenant, the token's expiry, the transport in use and the contract hash the server reports

[figure: ExtensionSession is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `person` | `id` | yes |  |
| `tenant` | `id` | yes |  |
| `expires` | `time` | yes |  |
| `transport` | `one of loopback \| gateway` | yes |  |
| `contract_hash` | `hash` | yes |  |



## Routes that use it
No route takes or returns ExtensionSession directly. The record holds it, and the objects that point at it reach it.


---
title: "ExtractedArticle"
description: "the main content of a page as the carried extractor returns it: title, author, published time with its basis, language, word count, the extractor used and its quality score"
section: concepts
address: /concepts/extractedarticle
contract: 0476e35e6e275db5
---

# ExtractedArticle

the main content of a page as the carried extractor returns it: title, author, published time with its basis, language, word count, the extractor used and its quality score

[figure: ExtractedArticle is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `title` | `text` | yes |  |
| `author` | `text` | no |  |
| `published_at` | `time` | no |  |
| `basis_of_time` | `one of published \| scheduled \| first seen` | yes |  |
| `content_markdown` | `text` | yes |  |
| `language` | `text` | yes |  |
| `word_count` | `count` | yes |  |
| `extractor` | `text` | yes | which extractor produced it |
| `quality` | `share` | yes | prose quality in [0, 1]; 0 when unknown |
| `content_hash` | `hash` | yes |  |



## Routes that use it
No route takes or returns ExtractedArticle directly. The record holds it, and the objects that point at it reach it.


---
title: "ExtractionTemplate"
description: "the scraping framework's unit: what a page kind looks like, how far to walk, how to render and navigate, what to extract, how each field is normalised, what makes a row the same row, which source object and mapping the rows become, under which policies, proved by recorded samples"
section: concepts
address: /concepts/extractiontemplate
contract: 0476e35e6e275db5
---

# ExtractionTemplate

the scraping framework's unit: what a page kind looks like, how far to walk, how to render and navigate, what to extract, how each field is normalised, what makes a row the same row, which source object and mapping the rows become, under which policies, proved by recorded samples

[figure: ExtractionTemplate is a definition at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | follows |
| key | its name and version, a tenant's or the platform's |
| store | postgres |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `page_kind` | `one of listing \| detail \| feed \| table \| search results \| infinite scroll \| document \| API response` | yes |  |
| `scope` | [CrawlScope](/concepts/crawlscope) | yes | maps onto spider-rs's configuration |
| `render` | `one of static \| auto \| rendered` | yes |  |
| `navigation` | [BrowsingStep](/concepts/browsingstep) | yes | run on CloakBrowser before extraction: open, click, type, scroll, wait, paginate |
| `fields` | [FieldSpec](/concepts/fieldspec) | yes |  |
| `schema` | `json` | no | for the model-assisted reader, every value with its evidence span |
| `normalisation` | [NormalisationRule](/concepts/normalisationrule) | yes |  |
| `dedup_key` | `[text]` | yes | the fields that make one row the same row across reads |
| `source_object` | [SourceObject](/concepts/sourceobject) | yes |  |
| `mapping` | [Mapping](/concepts/mapping) | no |  |
| `filter` | [ResourceFilter](/concepts/resourcefilter) | yes |  |
| `identity_needed` | `text` | no |  |
| `proxy_policy` | [ProxyPolicy](/concepts/proxypolicy) | no |  |
| `freshness` | `duration` | yes | how long a read stays good; a re-read before it is a read of bronze |
| `attempt_caps` | `{text:count}` | yes | by failure class |
| `budget` | `{text:count}` | yes | pages, bytes, money |
| `copied_from` | `id` | no | the platform original a tenant copied |
| `samples_hash` | `hash` | no | the recorded pages and their expected rows |
| `state` | [Readiness](/concepts/readiness) | yes | ready only when the samples check passes |
| `kind_of_entity` | [KindOfEntity](/concepts/kindofentity) | no | the kind of entity a page of this template shows first |



## Routes that use it
- [`/v1/ask/propose_template`](/reference/ask/propose_template) returns it
- [`/v1/act/scrape_template`](/reference/act/scrape_template) returns it


---
title: "Facet"
description: "a proxy of the membership engine built by one procedure, with its four views"
section: concepts
address: /concepts/facet
contract: 0476e35e6e275db5
---

# Facet

a proxy of the membership engine built by one procedure, with its four views

[figure: Facet is a definition at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | follows |
| key | the proxy it is |
| store | postgres |
| family | rules_engine |



## Fields


| field | type | required | note |
|---|---|---|---|
| `proxy` | `id` | yes |  |
| `seed` | `text` | yes |  |
| `candidates` | [FacetCandidate](/concepts/facetcandidate) | yes | each saying which way found it |
| `bar` | `number` | yes | in lift units, set from both sides: a room is kept when the lower bound of its share, over the seed's base rate, is at or over it; never under one, which is chance |
| `base_rate` | `share` | no | the share of everyone active in the window who is the seed's people: the chance a room's share is measured against |
| `negative_controls` | [ControlResult](/concepts/controlresult) | yes |  |
| `positive_controls` | [ControlResult](/concepts/controlresult) | yes |  |
| `gazetteer` | `id` | no | for a place facet |
| `scope` | [Scope](/concepts/scope) | yes | the scope the facet was built at and its memberships land in: shared for a buyers' facet that every tenant reads, built by the platform's own tenant; tenant for a tenant's own facet |



## Routes that use it
- [`/v1/work/build_facet`](/reference/work/build_facet) returns it


---
title: "FacetCandidate"
description: "a candidate community of a facet"
section: concepts
address: /concepts/facetcandidate
contract: 0476e35e6e275db5
---

# FacetCandidate

a candidate community of a facet

[figure: FacetCandidate is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | rules_engine |



## Fields


| field | type | required | note |
|---|---|---|---|
| `community` | `id` | yes |  |
| `found_by` | `one of lexical \| behavioural \| semantic` | yes | which way found it |
| `overlap` | `share` | yes | the share of the room's people who are the seed's, as measured |
| `lift` | `number` | no | the lower bound of that share at the engine's confidence, over the seed's base rate: the measure the room is kept by |
| `kept` | `bool` | yes |  |
| `reason` | `text` | yes |  |
| `adult_share` | `share` | no | the share of the room's posts that its platform marks adult, as counted from the posts; absent when the presence reads no texts |
| `adult` | `bool` | yes | true when the share is at or over the share that marks a room adult; a marked room is kept by the same bar as any other and left out of every read by default |



## Routes that use it
No route takes or returns FacetCandidate directly. The record holds it, and the objects that point at it reach it.


---
title: "FacetKind"
description: "a kind of facet, a closed register a person extends by a row"
section: concepts
address: /concepts/facetkind
contract: 0476e35e6e275db5
---

# FacetKind

a kind of facet, a closed register a person extends by a row

[figure: FacetKind is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | its name |
| store | postgres |
| family | rules_engine |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes | place, condition, profession, life stage, interest, brand affinity, institution, firmographic, role, language, a need state, a rung, a posture of trust, a role of influence, a routing role |
| `aggregate_only_by_rule` | `bool` | yes |  |



## Routes that use it
No route takes or returns FacetKind directly. The record holds it, and the objects that point at it reach it.


---
title: "FactBase"
description: "what every fact carries beyond the unit, and cannot be written without"
section: concepts
address: /concepts/factbase
contract: 0476e35e6e275db5
---

# FactBase

what every fact carries beyond the unit, and cannot be written without

[figure: FactBase is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | carried by every fact |
| store | none |
| family | kernel |



## Fields


| field | type | required | note |
|---|---|---|---|
| `happened_at` | [TimeWithBasis](/concepts/timewithbasis) | yes | when it happened, with whether that time was published, scheduled or first seen |
| `learned_at` | `time` | yes | when we learned it |
| `source` | [SourceRef](/concepts/sourceref) | yes | the source, the way it was reached, and how it was fetched |
| `made_from` | `[id]` | yes | the units it was made from, walkable back to the observation and the sentence |
| `basis` | [Basis](/concepts/basis) | yes | observed, stated by a source, derived by a named rule, estimated with an interval |
| `maker` | `text` | yes | the rule, model or person that made it |
| `rights` | [Rights](/concepts/rights) | yes | copied from the source's row; a derived fact's are the most restrictive of its sources', read afresh |
| `plane` | [Plane](/concepts/plane) | yes | shared, or one tenant's; part of the type, so a leak does not compile |



## Routes that use it
No route takes or returns FactBase directly. The record holds it, and the objects that point at it reach it.


---
title: "FactsAnswer"
description: "the facts, and the tier that gave them"
section: concepts
address: /concepts/factsanswer
contract: 0476e35e6e275db5
---

# FactsAnswer

the facts, and the tier that gave them

[figure: FactsAnswer is a view at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `claims` | [Claim](/concepts/claim) | yes |  |
| `connections` | [Connection](/concepts/connection) | yes |  |
| `readings` | [ReadingOfMeasure](/concepts/readingofmeasure) | yes |  |
| `events` | [MarketEvent](/concepts/marketevent) | yes |  |
| `tier` | `text` | yes |  |



## Routes that use it
- [`/v1/ask/facts`](/reference/ask/facts) returns it


---
title: "FactsInput"
description: "a unit or a population, as of two dates"
section: concepts
address: /concepts/factsinput
contract: 0476e35e6e275db5
---

# FactsInput

a unit or a population, as of two dates

[figure: FactsInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `unit` | [UnitRef](/concepts/unitref) | no |  |
| `population` | [Predicate](/concepts/predicate) | no |  |
| `attributes` | `[text]` | no |  |



## Routes that use it
- [`/v1/ask/facts`](/reference/ask/facts) takes it as input


---
title: "FailedCall"
description: "a signed call that did not land, with why, and a way to send it again"
section: concepts
address: /concepts/failedcall
contract: 0476e35e6e275db5
---

# FailedCall

a signed call that did not land, with why, and a way to send it again

[figure: FailedCall is a fact at tenant scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | tenant |
| key | the telling and the moment |
| store | postgres+lake |
| family | gateway |



## Fields


| field | type | required | note |
|---|---|---|---|
| `telling` | `id` | yes |  |
| `event` | `id` | yes |  |
| `why` | `text` | yes |  |
| `tries` | `count` | yes |  |
| `send_again` | `text` | yes |  |



## Routes that use it
No route takes or returns FailedCall directly. The record holds it, and the objects that point at it reach it.


---
title: "FailureClass"
description: "the class every reason of failure carries"
section: concepts
address: /concepts/failureclass
contract: 0476e35e6e275db5
---

# FailureClass

the class every reason of failure carries

[figure: FailureClass is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | kernel |



## Fields


| field | type | required | note |
|---|---|---|---|
| `who` | `one of the unit's own \| the source's \| ours` | yes |  |
| `what` | `one of absent \| forbidden \| rate \| dependency down \| platform fault \| the unit's own` | yes |  |



## Routes that use it
No route takes or returns FailureClass directly. The record holds it, and the objects that point at it reach it.


---
title: "FeedbackLoop"
description: "one loop of a systems model: balancing or reinforcing, the stocks it runs through, its delay and its limit"
section: concepts
address: /concepts/feedbackloop
contract: 0476e35e6e275db5
---

# FeedbackLoop

one loop of a systems model: balancing or reinforcing, the stocks it runs through, its delay and its limit

[figure: FeedbackLoop is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `kind` | `one of balances \| reinforces` | yes |  |
| `through` | `[text]` | yes | the stocks it passes, in order |
| `delay` | `duration` | no |  |
| `limit` | `text` | yes | what limits it, or breaks it; a reinforcing loop with no limit is not ready |
| `gain` | [KindOfMeasure](/concepts/kindofmeasure) | no | the measure that reads its gain |



## Routes that use it
No route takes or returns FeedbackLoop directly. The record holds it, and the objects that point at it reach it.


---
title: "FieldSpec"
description: "one field of an extraction: its name, how it is found (a CSS selector, an XPath, a regular expression, a JSON path), the attribute read, its type, whether many, and nested fields"
section: concepts
address: /concepts/fieldspec
contract: 0476e35e6e275db5
---

# FieldSpec

one field of an extraction: its name, how it is found (a CSS selector, an XPath, a regular expression, a JSON path), the attribute read, its type, whether many, and nested fields

[figure: FieldSpec is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `selector_kind` | `one of css \| xpath \| regex \| json path` | yes |  |
| `selector` | `text` | yes |  |
| `attribute` | `text` | no | text by default; for a pattern, where it runs: the visible text by default, address (the page's own address), nodes (the text nodes joined by a bar) or html (the page's markup, or the item's inside a list, so an identity kept in a data attribute or a link is read the same way on every surface) |
| `type` | `text` | yes | a type of the register |
| `many` | `bool` | yes |  |
| `fields` | [FieldSpec](/concepts/fieldspec) | no | nested |



## Routes that use it
No route takes or returns FieldSpec directly. The record holds it, and the objects that point at it reach it.


---
title: "Figure"
description: "a figure of a recipe: what it shows, its form, the units it reads, the chip on every number"
section: concepts
address: /concepts/figure
contract: 0476e35e6e275db5
---

# Figure

a figure of a recipe: what it shows, its form, the units it reads, the chip on every number

[figure: Figure is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | documents |



## Fields


| field | type | required | note |
|---|---|---|---|
| `label` | `text` | yes |  |
| `form` | `text` | yes | from the catalogue of forms |
| `reads` | `[id]` | yes |  |
| `chips` | [Basis](/concepts/basis) | yes |  |



## Routes that use it
No route takes or returns Figure directly. The record holds it, and the objects that point at it reach it.


---
title: "FileEntry"
description: "one file of the workspace"
section: concepts
address: /concepts/fileentry
contract: 0476e35e6e275db5
---

# FileEntry

one file of the workspace

[figure: FileEntry is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `path` | `text` | yes |  |
| `bytes` | `bytes` | yes |  |
| `kind` | `text` | yes |  |
| `written_at` | `time` | yes |  |



## Routes that use it
No route takes or returns FileEntry directly. The record holds it, and the objects that point at it reach it.


---
title: "FileList"
description: "the files with their sizes, kinds and when they were written"
section: concepts
address: /concepts/filelist
contract: 0476e35e6e275db5
---

# FileList

the files with their sizes, kinds and when they were written

[figure: FileList is a view at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `files` | [FileEntry](/concepts/fileentry) | yes |  |



## Routes that use it
- [`/v1/files/list`](/reference/files/list) returns it


---
title: "FileTransfer"
description: "progress by bytes moved of bytes in all, then the path or the pointer"
section: concepts
address: /concepts/filetransfer
contract: 0476e35e6e275db5
---

# FileTransfer

progress by bytes moved of bytes in all, then the path or the pointer

[figure: FileTransfer is a view at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `progress` | [Progress](/concepts/progress) | yes |  |
| `path` | `text` | no |  |
| `pointer` | `id` | no |  |



## Routes that use it
- [`/v1/files/download`](/reference/files/download) returns it
- [`/v1/files/upload`](/reference/files/upload) returns it


---
title: "FillOfMeaning"
description: "the fill of quantized embeddings for one partition"
section: concepts
address: /concepts/fillofmeaning
contract: 0476e35e6e275db5
---

# FillOfMeaning

the fill of quantized embeddings for one partition

[figure: FillOfMeaning is a work at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | work |
| scope | follows |
| key | one partition and one model |
| store | postgres |
| family | record |



## Fields


| field | type | required | note |
|---|---|---|---|
| `partition` | `id` | yes |  |
| `model` | [Model](/concepts/model) | yes |  |
| `texts` | `count` | yes |  |
| `already_held` | `count` | yes |  |
| `given_meaning` | `count` | yes |  |
| `cost` | [Cost](/concepts/cost) | yes |  |



## Routes that use it
No route takes or returns FillOfMeaning directly. The record holds it, and the objects that point at it reach it.


---
title: "FitBars"
description: "the value of the parameter row that sets the bar of fit and the level of its interval"
section: concepts
address: /concepts/fitbars
contract: 0476e35e6e275db5
---

# FitBars

the value of the parameter row that sets the bar of fit and the level of its interval

[figure: FitBars is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | people |



## Fields


| field | type | required | note |
|---|---|---|---|
| `bar` | `number` | yes | the mean a lead must reach; a required criterion must reach it and a disqualifying one must stay under one minus it |
| `level` | `number` | yes | the interval's level |



## Routes that use it
No route takes or returns FitBars directly. The record holds it, and the objects that point at it reach it.


---
title: "FitCandidateMarket"
description: "one market the search scored: its unmet demand and its supply from the template's run, its rivals, the plays that would be alpha there and the ones that are table stakes, and its score with the reasons"
section: concepts
address: /concepts/fitcandidatemarket
contract: 0476e35e6e275db5
---

# FitCandidateMarket

one market the search scored: its unmet demand and its supply from the template's run, its rivals, the plays that would be alpha there and the ones that are table stakes, and its score with the reasons

[figure: FitCandidateMarket is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `vertical` | `id` | yes |  |
| `segment` | `id` | no |  |
| `unmet_demand` | [Summary](/concepts/summary) | yes |  |
| `supply` | [Summary](/concepts/summary) | yes |  |
| `rivals` | `count` | yes |  |
| `alpha_plays` | [Tactic](/concepts/tactic) | yes |  |
| `table_stakes` | [Tactic](/concepts/tactic) | yes |  |
| `score` | [Interval](/concepts/interval) | yes |  |
| `reasons` | `[text]` | yes |  |



## Routes that use it
No route takes or returns FitCandidateMarket directly. The record holds it, and the objects that point at it reach it.


---
title: "FitFrameInput"
description: "the search whose frame is read"
section: concepts
address: /concepts/fitframeinput
contract: 0476e35e6e275db5
---

# FitFrameInput

the search whose frame is read

[figure: FitFrameInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `search` | `id` | yes |  |



## Routes that use it
- [`/v1/read/fit_frame`](/reference/read/fit_frame) takes it as input


---
title: "FitPlaysInput"
description: "the phase of the search, and the vertical or kind of offering the tactics must fit"
section: concepts
address: /concepts/fitplaysinput
contract: 0476e35e6e275db5
---

# FitPlaysInput

the phase of the search, and the vertical or kind of offering the tactics must fit

[figure: FitPlaysInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `phase` | `one of find the market \| sculpt the offering \| test the fit \| build a beachhead \| engineer demand \| find demand \| grow in a market \| hedge` | yes |  |
| `vertical` | `id` | no |  |
| `kind_of_offering` | [KindOfOffering](/concepts/kindofoffering) | no |  |



## Routes that use it
- [`/v1/read/fit_plays`](/reference/read/fit_plays) takes it as input


---
title: "FitReading"
description: "one result of a person's own product-market-fit test, as a reading the record keeps beside its readings: the tactic run, the market it was run in, the measure and its value in one of three positions, the sample, where it came from, and the hypothesis it settles"
section: concepts
address: /concepts/fitreading
contract: 0476e35e6e275db5
---

# FitReading

one result of a person's own product-market-fit test, as a reading the record keeps beside its readings: the tactic run, the market it was run in, the measure and its value in one of three positions, the sample, where it came from, and the hypothesis it settles

[figure: FitReading is a fact at brand scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | brand |
| key | the tactic, the market, the measure and the time |
| store | postgres+lake |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `tactic` | [Tactic](/concepts/tactic) | yes |  |
| `vertical` | `id` | yes |  |
| `segment` | `id` | no |  |
| `offering` | `id` | no |  |
| `measure` | [KindOfMeasure](/concepts/kindofmeasure) | yes |  |
| `value` | [Summary](/concepts/summary) | yes |  |
| `sample` | `count` | no |  |
| `read_at` | `time` | yes |  |
| `source` | `one of a form \| a CRM \| a capture \| an upload \| a call \| the record` | yes |  |
| `hypothesis` | `id` | no |  |
| `note` | `text` | no |  |



## Routes that use it
- [`/v1/act/record_fit_reading`](/reference/act/record_fit_reading) returns it


---
title: "FitReadingInput"
description: "one result of a person's own fit test, as they state it"
section: concepts
address: /concepts/fitreadinginput
contract: 0476e35e6e275db5
---

# FitReadingInput

one result of a person's own fit test, as they state it

[figure: FitReadingInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `tactic` | [Tactic](/concepts/tactic) | yes |  |
| `vertical` | `id` | yes |  |
| `segment` | `id` | no |  |
| `offering` | `id` | no |  |
| `measure` | [KindOfMeasure](/concepts/kindofmeasure) | yes |  |
| `value` | `json` | yes | the number, or never measured with the reason |
| `sample` | `count` | no |  |
| `source` | `one of a form \| a CRM \| a capture \| an upload \| a call \| the record` | yes |  |
| `hypothesis` | `id` | no |  |
| `note` | `text` | no |  |



## Routes that use it
- [`/v1/act/record_fit_reading`](/reference/act/record_fit_reading) takes it as input


---
title: "FitScore"
description: "the fit of an entity to a kind of buyer as a weighted mean over its criteria with a Beta interval"
section: concepts
address: /concepts/fitscore
contract: 0476e35e6e275db5
---

# FitScore

the fit of an entity to a kind of buyer as a weighted mean over its criteria with a Beta interval

[figure: FitScore is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | people |



## Fields


| field | type | required | note |
|---|---|---|---|
| `mean` | `number` | yes |  |
| `lower` | `number` | yes |  |
| `upper` | `number` | yes |  |
| `level` | `number` | yes | the interval's level |
| `criteria_evaluated` | `count` | yes |  |
| `criteria_missing` | `count` | yes |  |



## Routes that use it
No route takes or returns FitScore directly. The record holds it, and the objects that point at it reach it.


---
title: "FitSearch"
description: "the search for product-market fit from either end: an offering looking for its most advantageous markets, or a concept looking for whether a market exists and how to sculpt the offering to unmet demand; each step a hypothesis settled by readings"
section: concepts
address: /concepts/fitsearch
contract: 0476e35e6e275db5
---

# FitSearch

the search for product-market fit from either end: an offering looking for its most advantageous markets, or a concept looking for whether a market exists and how to sculpt the offering to unmet demand; each step a hypothesis settled by readings

[figure: FitSearch is a work at brand scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | work |
| scope | brand |
| key | the brand, the end it starts from and the inputs hash |
| store | postgres |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `brand` | `id` | yes |  |
| `from_end` | `one of an offering \| a concept` | yes |  |
| `offerings` | `[id]` | yes | empty for a concept |
| `concept` | `text` | no | for a concept: the business or offering in the person's words |
| `candidate_verticals` | `[id]` | yes | empty asks for every vertical the register holds |
| `inputs_hash` | `hash` | yes |  |
| `steps` | [FitStep](/concepts/fitstep) | yes |  |
| `frame` | `id` | no |  |
| `why_stopped` | `text` | no |  |



## Routes that use it
- [`/v1/work/search_fit`](/reference/work/search_fit) returns it


---
title: "FitSearchFrame"
description: "what a fit search gave: the markets ranked, the offering sculpted per buyer profile, the tactics proposed to test the fit, the verdict per market, and the set of options that compares the markets"
section: concepts
address: /concepts/fitsearchframe
contract: 0476e35e6e275db5
---

# FitSearchFrame

what a fit search gave: the markets ranked, the offering sculpted per buyer profile, the tactics proposed to test the fit, the verdict per market, and the set of options that compares the markets

[figure: FitSearchFrame is a fact at brand scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | brand |
| key | the search |
| store | postgres+lake |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `search` | `id` | yes |  |
| `markets` | [FitCandidateMarket](/concepts/fitcandidatemarket) | yes | ranked |
| `sculpted` | [SculptedOffering](/concepts/sculptedoffering) | yes |  |
| `tactics` | [Tactic](/concepts/tactic) | yes | the tactics proposed, in the order to run them |
| `verdicts` | [FitVerdict](/concepts/fitverdict) | yes |  |
| `options` | `id` | no |  |



## Routes that use it
- [`/v1/read/fit_frame`](/reference/read/fit_frame) returns it


---
title: "FitSearchInput"
description: "the brand, the end the search starts from, its offerings or its concept, and the verticals to consider"
section: concepts
address: /concepts/fitsearchinput
contract: 0476e35e6e275db5
---

# FitSearchInput

the brand, the end the search starts from, its offerings or its concept, and the verticals to consider

[figure: FitSearchInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `brand` | `id` | yes |  |
| `from_end` | `one of an offering \| a concept` | yes |  |
| `offerings` | `[id]` | yes |  |
| `concept` | `text` | no |  |
| `candidate_verticals` | `[id]` | yes |  |



## Routes that use it
- [`/v1/work/search_fit`](/reference/work/search_fit) takes it as input


---
title: "FitStep"
description: "one step of the search, a hypothesis settled by readings"
section: concepts
address: /concepts/fitstep
contract: 0476e35e6e275db5
---

# FitStep

one step of the search, a hypothesis settled by readings

[figure: FitStep is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `one of the candidate markets \| the rivals' shape \| the buyer profiles \| the sculpted offering \| the plays to test \| the readings \| the verdict` | yes |  |
| `hypothesis` | `id` | no |  |
| `state` | [Readiness](/concepts/readiness) | yes |  |
| `started_at` | `time` | no |  |
| `settled_at` | `time` | no |  |



## Routes that use it
No route takes or returns FitStep directly. The record holds it, and the objects that point at it reach it.


---
title: "FitVerdict"
description: "the search's verdict for one market: fit, no fit or not yet read, with the readings behind it"
section: concepts
address: /concepts/fitverdict
contract: 0476e35e6e275db5
---

# FitVerdict

the search's verdict for one market: fit, no fit or not yet read, with the readings behind it

[figure: FitVerdict is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `vertical` | `id` | yes |  |
| `segment` | `id` | no |  |
| `verdict` | `one of fit \| no fit \| not yet read` | yes |  |
| `evidence` | [EvidenceRef](/concepts/evidenceref) | yes |  |
| `readings` | `[id]` | yes | the fit readings it rests on |



## Routes that use it
No route takes or returns FitVerdict directly. The record holds it, and the objects that point at it reach it.


---
title: "Flow"
description: "a kind of flow, as a row of the register: the only way a unit changes place or a new unit is made"
section: concepts
address: /concepts/flow
contract: 0476e35e6e275db5
---

# Flow

a kind of flow, as a row of the register: the only way a unit changes place or a new unit is made

[figure: Flow is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | its name |
| store | postgres |
| family | kernel |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `meaning` | `text` | yes |  |
| `unit_kind` | [Kind](/concepts/kind) | yes |  |
| `from_place` | `text` | no |  |
| `to_place` | `text` | no |  |
| `makes_kind` | [Kind](/concepts/kind) | no | for a flow that makes a fact |
| `emitted_by` | `text` | yes | the one part that emits it |
| `plane` | `one of tenant plane \| work plane` | yes |  |
| `version_of_shape` | `count` | yes |  |
| `repeat_rule` | `text` | yes | what makes a repeat harmless |
| `retention_class` | [RetentionClass](/concepts/retentionclass) | yes |  |
| `reasons` | `[text]` | yes | the typed reasons its outcomes may carry, each with its failure class |



## Routes that use it
No route takes or returns Flow directly. The record holds it, and the objects that point at it reach it.


---
title: "Forecast"
description: "written before the first action: the number expected and the number that proves it wrong, each with an interval"
section: concepts
address: /concepts/forecast
contract: 0476e35e6e275db5
---

# Forecast

written before the first action: the number expected and the number that proves it wrong, each with an interval

[figure: Forecast is a fact at strategy scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | strategy |
| key | the move |
| store | postgres+lake |
| family | strategy |



## Fields


| field | type | required | note |
|---|---|---|---|
| `move` | `id` | yes |  |
| `expected` | [Interval](/concepts/interval) | yes |  |
| `proves_wrong` | [Interval](/concepts/interval) | yes |  |
| `window` | `duration` | yes |  |
| `rule` | `text` | yes |  |
| `play_version` | `count` | yes |  |
| `tactic_version` | `count` | yes |  |
| `like_population` | [PopulationStatement](/concepts/populationstatement) | yes |  |
| `written_at` | `time` | yes |  |



## Routes that use it
No route takes or returns Forecast directly. The record holds it, and the objects that point at it reach it.


---
title: "ForecastAndEffect"
description: "one forecast and its effect"
section: concepts
address: /concepts/forecastandeffect
contract: 0476e35e6e275db5
---

# ForecastAndEffect

one forecast and its effect

[figure: ForecastAndEffect is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `forecast` | [Forecast](/concepts/forecast) | yes |  |
| `effect` | [Effect](/concepts/effect) | no |  |
| `held` | `bool` | no | true when the effect fell inside the forecast's band; absent while no effect stands |
| `score` | [ForecastScore](/concepts/forecastscore) | no | the proper score, once the effect stands; the same fact the record keeps |



## Routes that use it
No route takes or returns ForecastAndEffect directly. The record holds it, and the objects that point at it reach it.


---
title: "ForecastsAnswer"
description: "every forecast with its effect, how well the band held, and the proper score and the calibration by play, tactic, kind of buyer, framing, actor and content, so calibration is a read of this row and never a report of its own"
section: concepts
address: /concepts/forecastsanswer
contract: 0476e35e6e275db5
---

# ForecastsAnswer

every forecast with its effect, how well the band held, and the proper score and the calibration by play, tactic, kind of buyer, framing, actor and content, so calibration is a read of this row and never a report of its own

[figure: ForecastsAnswer is a view at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `pairs` | [ForecastAndEffect](/concepts/forecastandeffect) | yes |  |
| `band_held` | `share` | yes | the share of the effects that fell inside their forecast's band, over the pairs with an effect |
| `scored` | `count` | yes | the pairs with an effect and a score |
| `by_segment` | [ScoreBySegment](/concepts/scorebysegment) | yes | the scores and the calibration by segment; a segment under the calibration floor is not ready with the reason |



## Routes that use it
- [`/v1/read/forecasts`](/reference/read/forecasts) returns it


---
title: "ForecastScore"
description: "a forecast scored against its effect by the proper rule fixed on the row, read as of what was knowable when the forecast was written"
section: concepts
address: /concepts/forecastscore
contract: 0476e35e6e275db5
---

# ForecastScore

a forecast scored against its effect by the proper rule fixed on the row, read as of what was knowable when the forecast was written

[figure: ForecastScore is a fact at strategy scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | strategy |
| key | the forecast and the effect |
| store | postgres+lake |
| family | strategy |



## Fields


| field | type | required | note |
|---|---|---|---|
| `forecast` | `id` | yes |  |
| `effect` | `id` | yes |  |
| `rule` | `one of CRPS \| Brier \| log` | yes |  |
| `score` | `number` | yes |  |
| `play` | `id` | yes |  |
| `tactic` | [Tactic](/concepts/tactic) | yes |  |
| `framing` | [KindOfFraming](/concepts/kindofframing) | no |  |
| `actor` | `id` | no |  |
| `content` | `id` | no |  |
| `read_at` | `time` | yes |  |



## Routes that use it
No route takes or returns ForecastScore directly. The record holds it, and the objects that point at it reach it.


---
title: "ForecastsInput"
description: "a play or a tactic, across brands"
section: concepts
address: /concepts/forecastsinput
contract: 0476e35e6e275db5
---

# ForecastsInput

a play or a tactic, across brands

[figure: ForecastsInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `play` | `id` | no |  |
| `tactic` | [Tactic](/concepts/tactic) | no |  |



## Routes that use it
- [`/v1/read/forecasts`](/reference/read/forecasts) takes it as input


---
title: "FrameInput"
description: "one input a frame read, with where it came from and its basis"
section: concepts
address: /concepts/frameinput
contract: 0476e35e6e275db5
---

# FrameInput

one input a frame read, with where it came from and its basis

[figure: FrameInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | one input of a frame |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `driver` | [KindOfMeasure](/concepts/kindofmeasure) | yes |  |
| `value` | `json` | yes |  |
| `basis` | [Basis](/concepts/basis) | yes |  |
| `from` | `one of stated \| the record \| a benchmark \| a parameter \| computed \| withheld` | yes | a parameter: the stipulated position of a driver the setting rows hold, such as the platform's uplift until the outcome ledger measures it |
| `unit` | `id` | no | the stated number, the reading or the benchmark it read |
| `stale` | `bool` | yes | a benchmark past its age or with its rights withdrawn |



## Routes that use it
No route takes or returns FrameInput directly. The record holds it, and the objects that point at it reach it.


---
title: "Game"
description: "the game a strategy plays in its market, by value chain: the way of going to market, the twin's template, the roles that play, the play families that read alpha there, what is counted, and the dynamics it assumes"
section: concepts
address: /concepts/game
contract: 0476e35e6e275db5
---

# Game

the game a strategy plays in its market, by value chain: the way of going to market, the twin's template, the roles that play, the play families that read alpha there, what is counted, and the dynamics it assumes

[figure: Game is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | its name |
| store | postgres |
| family | strategy |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `way` | [WayOfGoingToMarket](/concepts/wayofgoingtomarket) | yes |  |
| `template` | [SystemsModelTemplate](/concepts/systemsmodeltemplate) | yes |  |
| `roles` | [RoleAroundADecision](/concepts/rolearoundadecision) | yes | the roles that play |
| `play_families` | `[one of demand engineering \| demand capture \| channel and partnership \| pricing \| positioning and proof \| offering design \| market entry and beachhead \| growth in a market \| retention and existing customers \| competitive \| regulatory and payer \| education and enablement \| sales motion and operations \| hedge and portfolio \| ecosystem and platform]` | yes | the families that read alpha in this game |
| `what_is_counted` | `text` | yes |  |
| `dynamics` | `text` | yes | the loops, delays and limits the game assumes, in the living market's words |
| `crowd` | `one of named players \| a mean field` | yes | whether the parties are named players or a crowd |



## Routes that use it
No route takes or returns Game directly. The record holds it, and the objects that point at it reach it.


---
title: "GameMove"
description: "one role's choice in a game of roles: the options it may choose among, its payoff as a driver tree over the frame's drivers, and its best response as the solver reports it"
section: concepts
address: /concepts/gamemove
contract: 0476e35e6e275db5
---

# GameMove

one role's choice in a game of roles: the options it may choose among, its payoff as a driver tree over the frame's drivers, and its best response as the solver reports it

[figure: GameMove is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `role` | [RoleAroundADecision](/concepts/rolearoundadecision) | yes |  |
| `options` | `[text]` | yes | the choices the role may make, in the vertical's words |
| `payoff` | [DriverNode](/concepts/drivernode) | yes | the role's payoff, a driver tree the one evaluator computes |
| `best_response` | `text` | no | the option the solver reports as the role's best response, with the interval; absent until solved |



## Routes that use it
No route takes or returns GameMove directly. The record holds it, and the objects that point at it reach it.


---
title: "GameOfRoles"
description: "a game-theoretic model laid over a template: the roles as players, each with its options and its payoff as a driver tree, and the equilibrium the solver reports; every payoff is computed by the one evaluator over the frame's drivers"
section: concepts
address: /concepts/gameofroles
contract: 0476e35e6e275db5
---

# GameOfRoles

a game-theoretic model laid over a template: the roles as players, each with its options and its payoff as a driver tree, and the equilibrium the solver reports; every payoff is computed by the one evaluator over the frame's drivers

[figure: GameOfRoles is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `players` | [RoleAroundADecision](/concepts/rolearoundadecision) | yes |  |
| `moves` | [GameMove](/concepts/gamemove) | yes |  |
| `solution_concept` | `one of a Nash equilibrium of the stage game \| a subgame-perfect equilibrium over the horizon \| a best-response dynamic` | yes |  |
| `equilibrium` | `text` | no | what the solver reports, in the roles' words; absent until solved |
| `evidence` | [EvidenceRef](/concepts/evidenceref) | no | the readings the payoffs rest on |



## Routes that use it
No route takes or returns GameOfRoles directly. The record holds it, and the objects that point at it reach it.


---
title: "Gazetteer"
description: "the register of places: a place's names and their forms, its parent in the hierarchy a count rolls up through, its coordinates and its cell, its population and its source"
section: concepts
address: /concepts/gazetteer
contract: 0476e35e6e275db5
---

# Gazetteer

the register of places: a place's names and their forms, its parent in the hierarchy a count rolls up through, its coordinates and its cell, its population and its source

[figure: Gazetteer is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | its place id |
| store | postgres |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `place_id` | `text` | yes | the registered place id |
| `names` | `[text]` | yes | the name and its forms |
| `parent` | `id` | no | the place a count rolls up into |
| `latitude` | `number` | yes | degrees |
| `longitude` | `number` | yes | degrees |
| `cell` | `text` | yes | the cell of one standard hierarchy of cells at the resolution the parameter names; the sort key of every place-keyed table |
| `population` | `count` | no |  |
| `source` | [Source](/concepts/source) | yes |  |
| `state` | [Readiness](/concepts/readiness) | yes | not ready without coordinates |
| `area` | `text` | no | a geometry in one standard encoding, for a place that is an area |
| `cells` | `[text]` | no | the cells the area covers, at the resolution parameter |
| `member_of` | `[id]` | no | overlapping areas outside the one parent |



## Routes that use it
No route takes or returns Gazetteer directly. The record holds it, and the objects that point at it reach it.


---
title: "Goal"
description: "a measure, a target, a window, and the version of the measure it was set against"
section: concepts
address: /concepts/goal
contract: 0476e35e6e275db5
---

# Goal

a measure, a target, a window, and the version of the measure it was set against

[figure: Goal is a definition at strategy scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | strategy |
| key | the strategy and the measure |
| store | postgres |
| family | strategy |



## Fields


| field | type | required | note |
|---|---|---|---|
| `strategy` | `id` | yes |  |
| `measure` | [KindOfMeasure](/concepts/kindofmeasure) | yes |  |
| `measure_version` | `count` | yes |  |
| `target` | `json` | yes |  |
| `window` | `duration` | yes |  |
| `reading` | [Measure](/concepts/measure) | no | the latest, with its basis |



## Routes that use it
- [`/v1/act/goal`](/reference/act/goal) returns it


---
title: "GoalInput"
description: "a goal to add"
section: concepts
address: /concepts/goalinput
contract: 0476e35e6e275db5
---

# GoalInput

a goal to add

[figure: GoalInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `goal` | [Goal](/concepts/goal) | yes |  |



## Routes that use it
- [`/v1/act/goal`](/reference/act/goal) takes it as input


---
title: "Grant"
description: "who may do what, where, in which mode, within which limits"
section: concepts
address: /concepts/grant
contract: 0476e35e6e275db5
---

# Grant

who may do what, where, in which mode, within which limits

[figure: Grant is a definition at tenant scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | tenant |
| key | who, what and where, versioned |
| store | postgres |
| family | people |



## Fields


| field | type | required | note |
|---|---|---|---|
| `who` | [GrantHolder](/concepts/grantholder) | yes |  |
| `permissions` | [Permission](/concepts/permission) | yes | named one by one, by what they do, or by reach |
| `reach` | [AccessScope](/concepts/accessscope) | no | the access scope the permissions were named by, where they were named by reach |
| `where` | [Scope](/concepts/scope) | yes |  |
| `data_group` | `id` | no |  |
| `mode` | `one of read only \| propose \| act \| full autonomy` | yes |  |
| `limits` | [GrantLimits](/concepts/grantlimits) | yes |  |
| `turned_on_by` | [Caller](/concepts/caller) | no | for full autonomy: who, explicitly, for this one scope |
| `ends_at` | `time` | no |  |



## Routes that use it
- [`/v1/act/grant`](/reference/act/grant) returns it


---
title: "GrantHolder"
description: "the holder of a grant"
section: concepts
address: /concepts/grantholder
contract: 0476e35e6e275db5
---

# GrantHolder

the holder of a grant

[figure: GrantHolder is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | people |



## Fields


| field | type | required | note |
|---|---|---|---|
| `kind` | `one of a user \| a role \| our agent \| a client \| a key` | yes |  |
| `id` | `id` | yes |  |



## Routes that use it
No route takes or returns GrantHolder directly. The record holds it, and the objects that point at it reach it.


---
title: "GrantInput"
description: "give, change or withdraw a grant"
section: concepts
address: /concepts/grantinput
contract: 0476e35e6e275db5
---

# GrantInput

give, change or withdraw a grant

[figure: GrantInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `grant` | [Grant](/concepts/grant) | no |  |
| `withdraw` | `id` | no |  |
| `reason` | `text` | yes |  |



## Routes that use it
- [`/v1/act/grant`](/reference/act/grant) takes it as input


---
title: "GrantLimits"
description: "the limits of a grant"
section: concepts
address: /concepts/grantlimits
contract: 0476e35e6e275db5
---

# GrantLimits

the limits of a grant

[figure: GrantLimits is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | people |



## Fields


| field | type | required | note |
|---|---|---|---|
| `budget` | [Cost](/concepts/cost) | no |  |
| `rate` | [RateBound](/concepts/ratebound) | no |  |
| `voices` | `[id]` | no |  |
| `sending_identities` | `[id]` | no |  |
| `kinds_of_reach` | `[text]` | no |  |



## Routes that use it
No route takes or returns GrantLimits directly. The record holds it, and the objects that point at it reach it.


---
title: "GrantRef"
description: "a grant as a caller sees it, after the three narrowings"
section: concepts
address: /concepts/grantref
contract: 0476e35e6e275db5
---

# GrantRef

a grant as a caller sees it, after the three narrowings

[figure: GrantRef is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | people |



## Fields


| field | type | required | note |
|---|---|---|---|
| `grant` | `id` | yes |  |
| `mode` | `one of read only \| propose \| act \| full autonomy` | yes |  |
| `permissions` | [Permission](/concepts/permission) | yes |  |
| `where` | [Scope](/concepts/scope) | yes |  |
| `data_group` | `text` | no | the data group the grant names, whose members are the only units the call may touch (test 2) |
| `limits` | [GrantLimits](/concepts/grantlimits) | no | the limits left on the grant: its budget, its rate, the voices and the sending identities it names (test 5) |
| `ends_at` | `time` | no | when the grant ends; a call after it is not allowed (test 5) |



## Routes that use it
No route takes or returns GrantRef directly. The record holds it, and the objects that point at it reach it.


---
title: "GrantsInput"
description: "the caller, and a place"
section: concepts
address: /concepts/grantsinput
contract: 0476e35e6e275db5
---

# GrantsInput

the caller, and a place

[figure: GrantsInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `place` | [Scope](/concepts/scope) | yes |  |



## Routes that use it
- [`/v1/session/my_grants`](/reference/session/my_grants) takes it as input


---
title: "GraphEdge"
description: "one edge of the graph a strategy, a play or a move is: from a done vertex to the next, guarded by a predicate over the record, or by the row always"
section: concepts
address: /concepts/graphedge
contract: 0476e35e6e275db5
---

# GraphEdge

one edge of the graph a strategy, a play or a move is: from a done vertex to the next, guarded by a predicate over the record, or by the row always

[figure: GraphEdge is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | strategy |



## Fields


| field | type | required | note |
|---|---|---|---|
| `from_vertex` | `id` | yes | the play, move or action the edge leaves |
| `to_vertex` | `id` | yes | the play, move or action the edge enters |
| `level` | `one of strategy \| play \| move` | yes | which graph the edge belongs to |
| `always` | `bool` | yes | true for a list edge with no predicate |
| `predicate` | [Predicate](/concepts/predicate) | no | absent when always; over the record's populations, the moves of the strategy, the actions of the move or the twin's stocks |
| `holds_by_horizon` | [Interval](/concepts/interval) | no | the chance the predicate holds before the horizon, from the rate at which it held before; never measured when it has no history |
| `state` | [Readiness](/concepts/readiness) | yes | not ready with the population named when the predicate cannot be evaluated |



## Routes that use it
No route takes or returns GraphEdge directly. The record holds it, and the objects that point at it reach it.


---
title: "Grounding"
description: "the grounding of one subject, a captured page, an entity, a text or an address: its mentions resolved and its relations suggested as hypotheses a person settles; staged when the subject is given, waiting for a person once the hypotheses are made, committed when every one is settled; the same work on every face"
section: concepts
address: /concepts/grounding
contract: 0476e35e6e275db5
---

# Grounding

the grounding of one subject, a captured page, an entity, a text or an address: its mentions resolved and its relations suggested as hypotheses a person settles; staged when the subject is given, waiting for a person once the hypotheses are made, committed when every one is settled; the same work on every face

[figure: Grounding is a work at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | work |
| scope | follows |
| key | the subject and the breadth |
| store | postgres |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `subject` | `one of a capture \| an entity \| a text \| an address` | yes | what was grounded |
| `capture` | `hash` | no | the artefact's hash, for a capture or an address the record holds a capture of |
| `text` | `text` | no | the text grounded, cut to 4,000 characters, for a text |
| `address` | `text` | yes | the page's address, the entity's own page, or empty for a text |
| `platform` | `text` | yes |  |
| `breadth` | `one of exact \| similar \| related \| broad` | yes |  |
| `entity` | `id` | no | the entity the page became |
| `hypotheses` | `[id]` | yes |  |
| `mentions` | `[id]` | yes |  |
| `channels` | `[text]` | yes | the channels that ran: exact keys, names, meaning, thread, neighbourhood |
| `candidates` | `count` | yes |  |
| `made_at` | `time` | yes |  |
| `settled_at` | `time` | no |  |
| `settled_by` | [Caller](/concepts/caller) | no |  |



## Routes that use it
No route takes or returns Grounding directly. The record holds it, and the objects that point at it reach it.


---
title: "GroundingAnswer"
description: "a grounding with its hypotheses, each with what it proposes"
section: concepts
address: /concepts/groundinganswer
contract: 0476e35e6e275db5
---

# GroundingAnswer

a grounding with its hypotheses, each with what it proposes

[figure: GroundingAnswer is a view at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `grounding` | [Grounding](/concepts/grounding) | yes |  |
| `hypotheses` | [Hypothesis](/concepts/hypothesis) | yes |  |



## Routes that use it
- [`/v1/act/ground`](/reference/act/ground) returns it


---
title: "GroundingPrior"
description: "how often a person supported a kind of suggestion on a platform at a breadth"
section: concepts
address: /concepts/groundingprior
contract: 0476e35e6e275db5
---

# GroundingPrior

how often a person supported a kind of suggestion on a platform at a breadth

[figure: GroundingPrior is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `kind` | `text` | yes | the kind of connection, or the face |
| `platform` | `text` | yes |  |
| `breadth` | `text` | yes |  |
| `supported` | `count` | yes |  |
| `refuted` | `count` | yes |  |
| `precision` | `share` | no | supported over settled, absent under ten settled |



## Routes that use it
No route takes or returns GroundingPrior directly. The record holds it, and the objects that point at it reach it.


---
title: "GroundingPriors"
description: "the priors, one row per kind, platform and breadth"
section: concepts
address: /concepts/groundingpriors
contract: 0476e35e6e275db5
---

# GroundingPriors

the priors, one row per kind, platform and breadth

[figure: GroundingPriors is a view at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `rows` | [GroundingPrior](/concepts/groundingprior) | yes |  |
| `settled` | `count` | yes |  |



## Routes that use it
- [`/v1/read/grounding_priors`](/reference/read/grounding_priors) returns it


---
title: "GroundingPriorsInput"
description: "the priors of grounding: one platform's, or every platform's"
section: concepts
address: /concepts/groundingpriorsinput
contract: 0476e35e6e275db5
---

# GroundingPriorsInput

the priors of grounding: one platform's, or every platform's

[figure: GroundingPriorsInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `platform` | `text` | no |  |



## Routes that use it
- [`/v1/read/grounding_priors`](/reference/read/grounding_priors) takes it as input


---
title: "GroundingsInput"
description: "which groundings to read: one capture's, one entity's, or every one in a place"
section: concepts
address: /concepts/groundingsinput
contract: 0476e35e6e275db5
---

# GroundingsInput

which groundings to read: one capture's, one entity's, or every one in a place

[figure: GroundingsInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `capture` | `hash` | no |  |
| `entity` | `id` | no |  |
| `place` | `one of staged \| grounding \| waiting for a person \| committed \| discarded \| all` | no |  |



## Routes that use it
- [`/v1/read/groundings`](/reference/read/groundings) takes it as input


---
title: "GroundInput"
description: "a subject to ground at a breadth: exactly one of a capture, an entity, a text or an address; the same grounding serves the capture panel, the entity page of the web and desktop shells, the agent and the API"
section: concepts
address: /concepts/groundinput
contract: 0476e35e6e275db5
---

# GroundInput

a subject to ground at a breadth: exactly one of a capture, an entity, a text or an address; the same grounding serves the capture panel, the entity page of the web and desktop shells, the agent and the API

[figure: GroundInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `capture` | `hash` | no | the artefact's hash |
| `entity` | `id` | no | an entity of the record |
| `text` | `text` | no | a text a person or the agent pasted, cut to 4,000 characters |
| `address` | `text` | no | an address of a page the record may hold as a capture |
| `breadth` | `one of exact \| similar \| related \| broad` | no | the person's default when absent |



## Routes that use it
- [`/v1/act/ground`](/reference/act/ground) takes it as input


---
title: "GroupsInput"
description: "a scope, the two dates, and the resolution of the cut"
section: concepts
address: /concepts/groupsinput
contract: 0476e35e6e275db5
---

# GroupsInput

a scope, the two dates, and the resolution of the cut

[figure: GroupsInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `scope` | [Predicate](/concepts/predicate) | yes |  |
| `resolution` | `share` | yes |  |



## Routes that use it
- [`/v1/ask/groups`](/reference/ask/groups) takes it as input


---
title: "HeaderRule"
description: "how a kind of connection is read off the shared silver header: each role bound to one header column, and the rows the rule applies to"
section: concepts
address: /concepts/headerrule
contract: 0476e35e6e275db5
---

# HeaderRule

how a kind of connection is read off the shared silver header: each role bound to one header column, and the rows the rule applies to

[figure: HeaderRule is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | record |



## Fields


| field | type | required | note |
|---|---|---|---|
| `roles` | `{text:enum:own_id \| author_account \| parent \| thread_root \| community}` | yes | the kind's role, and the header column that fills it |
| `when` | `one of always \| the row is its thread's root \| the row has a parent` | yes | which rows of silver the rule reads |
| `version` | `count` | yes | the rule's version, written on every connection the view yields |



## Routes that use it
No route takes or returns HeaderRule directly. The record holds it, and the objects that point at it reach it.


---
title: "HealthCheck"
description: "a signal that can fail, its vacuity guard, and where it runs"
section: concepts
address: /concepts/healthcheck
contract: 0476e35e6e275db5
---

# HealthCheck

a signal that can fail, its vacuity guard, and where it runs

[figure: HealthCheck is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | the service |
| store | postgres |
| family | operations |



## Fields


| field | type | required | note |
|---|---|---|---|
| `service` | `text` | yes |  |
| `signal` | `text` | yes |  |
| `vacuity_guard` | `text` | yes |  |
| `runs_on` | `one of the server` | yes |  |



## Routes that use it
No route takes or returns HealthCheck directly. The record holds it, and the objects that point at it reach it.


---
title: "HeldArtefact"
description: "the value of the parameter the artefacts on this machine: one lake, catalogue or folder of files still outside the one lakehouse, read in place until its tables are mapped in, with the name the engine opens it under, the registered source its tables derive from, its path, the program that made it and the repository…"
section: concepts
address: /concepts/heldartefact
contract: 0476e35e6e275db5
---

# HeldArtefact

the value of the parameter the artefacts on this machine: one lake, catalogue or folder of files still outside the one lakehouse, read in place until its tables are mapped in, with the name the engine opens it under, the registered source its tables derive from, its path, the program that made it and the repository…

[figure: HeldArtefact is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes | one word the engine opens it under, which an SQL statement names it by |
| `source` | `id` | yes | the registered source its tables derive from |
| `path` | `text` | yes | the file or folder on this machine |
| `generator` | `text` | yes | the program that made it, as its own row names it |
| `repository` | `text` | no | the repository whose commit at the reading is appended to the generator; absent when the generator names its commit itself |



## Routes that use it
No route takes or returns HeldArtefact directly. The record holds it, and the objects that point at it reach it.


---
title: "HeldCookie"
description: "one cookie of a held identity's session state, as the browser gave it"
section: concepts
address: /concepts/heldcookie
contract: 0476e35e6e275db5
---

# HeldCookie

one cookie of a held identity's session state, as the browser gave it

[figure: HeldCookie is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `value` | `text` | yes | never returned by a tool and never logged |
| `domain` | `text` | yes |  |
| `path` | `text` | yes |  |
| `expires` | `number` | no | seconds since the epoch; absent for a session cookie |
| `secure` | `bool` | yes |  |
| `http_only` | `bool` | yes |  |



## Routes that use it
No route takes or returns HeldCookie directly. The record holds it, and the objects that point at it reach it.


---
title: "HeldSessionState"
description: "the session state of a held identity, sealed with the identities' key and kept in the record, so that every copy of the platform reads one store; the key never enters the record, and no tool returns this row"
section: concepts
address: /concepts/heldsessionstate
contract: 0476e35e6e275db5
---

# HeldSessionState

the session state of a held identity, sealed with the identities' key and kept in the record, so that every copy of the platform reads one store; the key never enters the record, and no tool returns this row

[figure: HeldSessionState is a definition at tenant scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | tenant |
| key | the identity's store entry |
| store | postgres |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `vault_entry` | `id` | yes | the identity's store entry, which its SignedInIdentity row carries |
| `key_name` | `text` | yes | the environment name of the key that sealed the state |
| `nonce` | `text` | no | the seal's nonce as hex; absent when the state was forgotten |
| `sealed` | `text` | no | the sealed session state as hex; absent when the state was forgotten |
| `checkpointed_at` | `time` | yes |  |



## Routes that use it
No route takes or returns HeldSessionState directly. The record holds it, and the objects that point at it reach it.


---
title: "Highlight"
description: "the words of one observation that met a criterion"
section: concepts
address: /concepts/highlight
contract: 0476e35e6e275db5
---

# Highlight

the words of one observation that met a criterion

[figure: Highlight is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | people |



## Fields


| field | type | required | note |
|---|---|---|---|
| `evidence` | [EvidenceRef](/concepts/evidenceref) | yes | the observation |
| `from` | `count` | yes | the first character |
| `to` | `count` | yes | the character after the last |
| `words` | `text` | yes | the span itself |



## Routes that use it
No route takes or returns Highlight directly. The record holds it, and the objects that point at it reach it.


---
title: "HoldIdentityInput"
description: "a signed-in identity to hold for the tenant: the platform's own browser opens on the platform, the person signs in, and the session state is checkpointed once the probe reads signed in"
section: concepts
address: /concepts/holdidentityinput
contract: 0476e35e6e275db5
---

# HoldIdentityInput

a signed-in identity to hold for the tenant: the platform's own browser opens on the platform, the person signs in, and the session state is checkpointed once the probe reads signed in

[figure: HoldIdentityInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `platform` | `text` | yes | the platform's slug, a row of the platform domains |
| `label` | `text` | yes | the person's name for this identity, unique within the tenant and platform |
| `wait_seconds` | `count` | no | how long the platform waits for the sign-in; the parameter row's value when absent |
| `session` | `id` | no | an open browsing session with a live view in which the person signed in; the platform reads the session's cookies as the session given, so nothing leaves any browser; the web version's way that lasts |
| `cookies` | [HeldCookie](/concepts/heldcookie) | no | the session's cookies given as data, read from the person's own browser by the platform's own extension or pasted by the person, for the web version where no window of the platform can open beside the person; when given, no window opens, and the platform keeps the cookies of the platform's domains and probes them |



## Routes that use it
- [`/v1/act/hold_identity`](/reference/act/hold_identity) takes it as input


---
title: "HopStamp"
description: "one hop of an acquisition unit through the system: the stage, the host, the time, the job, and the trace and span that hop wrote, so the unit's flow is one trace"
section: concepts
address: /concepts/hopstamp
contract: 0476e35e6e275db5
---

# HopStamp

one hop of an acquisition unit through the system: the stage, the host, the time, the job, and the trace and span that hop wrote, so the unit's flow is one trace

[figure: HopStamp is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | registers |



## Fields


| field | type | required | note |
|---|---|---|---|
| `stage` | `one of fetched \| captured \| deposited \| refined \| closed \| handed over \| accepted \| matched \| delivered` | yes |  |
| `host` | `text` | yes |  |
| `at` | `time` | yes |  |
| `job` | `id` | yes |  |
| `trace_id` | `text` | yes | the W3C trace id of the unit's flow |
| `span_id` | `text` | yes | this hop's span |



## Routes that use it
No route takes or returns HopStamp directly. The record holds it, and the objects that point at it reach it.


---
title: "Hypothesis"
description: "a claim the record does not yet settle, one shape for its faces"
section: concepts
address: /concepts/hypothesis
contract: 0476e35e6e275db5
---

# Hypothesis

a claim the record does not yet settle, one shape for its faces

[figure: Hypothesis is a work at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | work |
| scope | follows |
| key | the claim and its subject |
| store | postgres |
| family | kernel |



## Fields


| field | type | required | note |
|---|---|---|---|
| `claim` | `text` | yes |  |
| `face` | `one of a possible match \| a candidate \| a part inferred from a website \| a forecast \| a proposed definition \| a suggested connection \| a suggested claim \| a done move \| a rival marking \| a play's class \| a propensity` | yes | the five faces of a claim under test, the three the grounding makes, the rival marking a person makes and settles at once, a play's class read on the beat and settled by the rule, and a propensity of an actor or a content for a lead, settled by the effects (MODELS/the-strategy-system-as-a-formal-model sections 3.2 and 7) |
| `subject` | `id` | yes |  |
| `subject_entity` | `id` | no |  |
| `evidence_for` | [EvidenceRef](/concepts/evidenceref) | yes |  |
| `evidence_against` | [EvidenceRef](/concepts/evidenceref) | yes |  |
| `tests` | [HypothesisTest](/concepts/hypothesistest) | yes | owed and run |
| `bar` | `text` | yes | what settles it |
| `decider` | `one of a person \| the agent under a grant \| the rule \| the effect` | yes |  |
| `standing` | `one of under test \| supported \| refuted \| cannot tell` | yes |  |
| `made_at` | `time` | yes |  |
| `settled_at` | `time` | no |  |
| `settled_by` | [Caller](/concepts/caller) | no |  |
| `proposes` | [ProposedFact](/concepts/proposedfact) | no | the fact the record would hold if the claim were supported, in the record's own shape |
| `breadth` | `one of exact \| similar \| related \| broad` | no | how wide the grounding cast when it made this claim |
| `score` | `share` | no | the grounding's nearness, before a person's word |
| `grounding` | `id` | no | the grounding that made it |



## Routes that use it
- [`/v1/act/settle`](/reference/act/settle) returns it
- [`/v1/act/weigh`](/reference/act/weigh) returns it


---
title: "HypothesisTest"
description: "a test a claim owes or has run"
section: concepts
address: /concepts/hypothesistest
contract: 0476e35e6e275db5
---

# HypothesisTest

a test a claim owes or has run

[figure: HypothesisTest is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | kernel |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `tool` | `text` | no | the tool that runs it |
| `state` | `one of owed \| run` | yes |  |
| `read` | `text` | no | what it read |
| `at` | `time` | no |  |



## Routes that use it
No route takes or returns HypothesisTest directly. The record holds it, and the objects that point at it reach it.


---
title: "Identifier"
description: "an identifier that names an entity; never removed when a handle changes"
section: concepts
address: /concepts/identifier
contract: 0476e35e6e275db5
---

# Identifier

an identifier that names an entity; never removed when a handle changes

[figure: Identifier is a fact at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | follows |
| key | the namespace, the value and the source |
| store | postgres+lake |
| family | identity |



## Fields


| field | type | required | note |
|---|---|---|---|
| `entity` | `id` | yes |  |
| `namespace` | `text` | yes |  |
| `value` | `text` | yes |  |
| `normalised` | `text` | yes |  |
| `trust_rank` | `count` | yes |  |



## Routes that use it
No route takes or returns Identifier directly. The record holds it, and the objects that point at it reach it.


---
title: "IdentityDecision"
description: "same, new or review, with the chance and the evidence; a wrong one is never edited"
section: concepts
address: /concepts/identitydecision
contract: 0476e35e6e275db5
---

# IdentityDecision

same, new or review, with the chance and the evidence; a wrong one is never edited

[figure: IdentityDecision is a fact at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | follows |
| key | the mention, the method and the resolver's version |
| store | postgres+lake |
| family | identity |



## Fields


| field | type | required | note |
|---|---|---|---|
| `mention` | `id` | yes |  |
| `method` | [IdentityMethod](/concepts/identitymethod) | yes |  |
| `resolver_version` | `text` | yes |  |
| `answer` | `one of same \| new \| review` | yes |  |
| `entity` | `id` | no |  |
| `chance` | `chance` | yes |  |
| `evidence` | [EvidenceRef](/concepts/evidenceref) | yes |  |
| `names_as_wrong` | `id` | no | a later decision names the one it corrects |



## Routes that use it
No route takes or returns IdentityDecision directly. The record holds it, and the objects that point at it reach it.


---
title: "IdentityMethod"
description: "a method of deciding identity, ready only after it is calibrated for its kind"
section: concepts
address: /concepts/identitymethod
contract: 0476e35e6e275db5
---

# IdentityMethod

a method of deciding identity, ready only after it is calibrated for its kind

[figure: IdentityMethod is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | its name and version |
| store | postgres |
| family | identity |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `kind` | [KindOfEntity](/concepts/kindofentity) | yes |  |
| `version` | `text` | yes |  |
| `planted_pairs` | `[id]` | yes |  |
| `state` | [Readiness](/concepts/readiness) | yes |  |
| `upper_bar` | `chance` | yes |  |
| `lower_bar` | `chance` | yes |  |
| `smallest_gap` | `chance` | yes |  |



## Routes that use it
No route takes or returns IdentityMethod directly. The record holds it, and the objects that point at it reach it.


---
title: "IdWithSource"
description: "an id for an object with the source that made it"
section: concepts
address: /concepts/idwithsource
contract: 0476e35e6e275db5
---

# IdWithSource

an id for an object with the source that made it

[figure: IdWithSource is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | registers |



## Fields


| field | type | required | note |
|---|---|---|---|
| `source` | [Source](/concepts/source) | yes |  |
| `namespace` | `text` | yes |  |
| `value` | `text` | yes |  |
| `stable` | `bool` | yes |  |



## Routes that use it
No route takes or returns IdWithSource directly. The record holds it, and the objects that point at it reach it.


---
title: "Impact"
description: "a kind of signal: the effect, the play, the tactic, the brand; it changes what happens next"
section: concepts
address: /concepts/impact
contract: 0476e35e6e275db5
---

# Impact

a kind of signal: the effect, the play, the tactic, the brand; it changes what happens next

[figure: Impact is a fact at strategy scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | strategy |
| key | the effect |
| store | postgres |
| family | strategy |



## Fields


| field | type | required | note |
|---|---|---|---|
| `effect` | `id` | yes |  |
| `play` | `id` | yes |  |
| `tactic` | [Tactic](/concepts/tactic) | yes |  |
| `brand` | `id` | yes |  |
| `signal` | `id` | yes |  |



## Routes that use it
No route takes or returns Impact directly. The record holds it, and the objects that point at it reach it.


---
title: "Incident"
description: "what was seen, the reading that found it, what was done, what changed, and the check added"
section: concepts
address: /concepts/incident
contract: 0476e35e6e275db5
---

# Incident

what was seen, the reading that found it, what was done, what changed, and the check added

[figure: Incident is a work at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | work |
| scope | platform |
| key | its id |
| store | postgres |
| family | operations |



## Fields


| field | type | required | note |
|---|---|---|---|
| `seen` | `text` | yes |  |
| `found_by` | `text` | yes |  |
| `done` | `text` | no |  |
| `changed` | `text` | no |  |
| `check_added` | [Law](/concepts/law) | no |  |



## Routes that use it
No route takes or returns Incident directly. The record holds it, and the objects that point at it reach it.


---
title: "Ingress"
description: "the Gateway API implementation in front of the API gateway, one copy per machine sharing certificates through secrets"
section: concepts
address: /concepts/ingress
contract: 0476e35e6e275db5
---

# Ingress

the Gateway API implementation in front of the API gateway, one copy per machine sharing certificates through secrets

[figure: Ingress is a definition at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | platform |
| key | its name |
| store | postgres |
| family | network |



## Fields


| field | type | required | note |
|---|---|---|---|
| `implementation` | `text` | yes | Envoy Gateway recommended |
| `routes` | [Route](/concepts/route) | yes |  |
| `copies` | `count` | yes | one per machine |
| `trusted_proxies` | `[address]` | yes | only the load balancer |
| `connection_limits` | [ConnectionLimits](/concepts/connectionlimits) | yes |  |



## Routes that use it
No route takes or returns Ingress directly. The record holds it, and the objects that point at it reach it.


---
title: "InstallConnectorInput"
description: "the connector, the ways, the identity and the settings"
section: concepts
address: /concepts/installconnectorinput
contract: 0476e35e6e275db5
---

# InstallConnectorInput

the connector, the ways, the identity and the settings

[figure: InstallConnectorInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `installed` | [InstalledConnector](/concepts/installedconnector) | yes |  |



## Routes that use it
- [`/v1/act/install_connector`](/reference/act/install_connector) takes it as input


---
title: "InstalledConnector"
description: "a connector a tenant set up, ready only when its identity is ready and a probe has answered"
section: concepts
address: /concepts/installedconnector
contract: 0476e35e6e275db5
---

# InstalledConnector

a connector a tenant set up, ready only when its identity is ready and a probe has answered

[figure: InstalledConnector is a definition at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | follows |
| key | the connector, on a tenant or a brand |
| store | postgres |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `connector` | [Connector](/concepts/connector) | yes |  |
| `ways` | [AccessMethod](/concepts/accessmethod) | yes |  |
| `identity` | `id` | yes | the signed-in identity or the key each uses |
| `settings` | `json` | yes |  |
| `last_probe` | [ControlResult](/concepts/controlresult) | no |  |
| `state` | [Readiness](/concepts/readiness) | yes |  |



## Routes that use it
- [`/v1/act/install_connector`](/reference/act/install_connector) returns it


---
title: "InstalledTemplate"
description: "which template a brand installed, at which version, and how many copies"
section: concepts
address: /concepts/installedtemplate
contract: 0476e35e6e275db5
---

# InstalledTemplate

which template a brand installed, at which version, and how many copies

[figure: InstalledTemplate is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `template` | `id` | yes |  |
| `version` | `count` | yes |  |
| `installed_at` | `time` | yes |  |
| `copies` | `[id]` | yes |  |



## Routes that use it
No route takes or returns InstalledTemplate directly. The record holds it, and the objects that point at it reach it.


---
title: "InstallPackAnswer"
description: "the copies made, each naming its origin"
section: concepts
address: /concepts/installpackanswer
contract: 0476e35e6e275db5
---

# InstallPackAnswer

the copies made, each naming its origin

[figure: InstallPackAnswer is a view at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `installed` | [InstalledTemplate](/concepts/installedtemplate) | yes |  |
| `copies` | [UnitRef](/concepts/unitref) | yes |  |
| `refused` | [Refusal](/concepts/refusal) | yes | for a template that is not ready |



## Routes that use it
- [`/v1/act/install_pack`](/reference/act/install_pack) returns it


---
title: "InstallPackInput"
description: "a brand, the template and its version"
section: concepts
address: /concepts/installpackinput
contract: 0476e35e6e275db5
---

# InstallPackInput

a brand, the template and its version

[figure: InstallPackInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `brand` | `id` | yes |  |
| `template` | `id` | yes |  |
| `version` | `count` | yes |  |



## Routes that use it
- [`/v1/act/install_pack`](/reference/act/install_pack) takes it as input


---
title: "InstructionSet"
description: "the agent's standing instructions for a kind of job, assembled from versioned rows at run time: the stance, the rules of evidence, the method by question, the reporting form, the stopping rule and the words"
section: concepts
address: /concepts/instructionset
contract: 0476e35e6e275db5
---

# InstructionSet

the agent's standing instructions for a kind of job, assembled from versioned rows at run time: the stance, the rules of evidence, the method by question, the reporting form, the stopping rule and the words

[figure: InstructionSet is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | its name and version |
| store | postgres |
| family | models |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes | research, first |
| `version` | `count` | yes |  |
| `stance` | `[text]` | yes |  |
| `rules_of_evidence` | `[text]` | yes | each naming the check that enforces it |
| `method_by_question` | `[json]` | yes | question shape, methods in order, not to use |
| `reporting_form` | `[text]` | yes |  |
| `stopping_rule` | `[text]` | yes |  |
| `words` | `[text]` | yes |  |
| `assembled` | `text` | yes | the text the agent receives, derived |
| `changed_by` | `id` | yes |  |
| `reason` | `text` | yes |  |
| `workbench` | `[text]` | yes | when and how the agent writes and runs code, as a named procedure under its grant |



## Routes that use it
- [`/v1/read/instruction_set`](/reference/read/instruction_set) returns it


---
title: "IntelligenceAnswer"
description: "a kind of intelligence about a subject: the facts with their basis, the coverage and the date"
section: concepts
address: /concepts/intelligenceanswer
contract: 0476e35e6e275db5
---

# IntelligenceAnswer

a kind of intelligence about a subject: the facts with their basis, the coverage and the date

[figure: IntelligenceAnswer is a view at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `subject` | `id` | yes |  |
| `kind` | `text` | yes |  |
| `facts` | [Claim](/concepts/claim) | yes |  |
| `coverage` | [Coverage](/concepts/coverage) | yes |  |
| `as_of` | [TwoDates](/concepts/twodates) | yes |  |



## Routes that use it
- [`/v1/read/intelligence`](/reference/read/intelligence) returns it


---
title: "IntelligenceInput"
description: "a subject and a kind of intelligence to read"
section: concepts
address: /concepts/intelligenceinput
contract: 0476e35e6e275db5
---

# IntelligenceInput

a subject and a kind of intelligence to read

[figure: IntelligenceInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `subject` | `id` | yes |  |
| `kind` | `text` | yes | one of the register's kinds |



## Routes that use it
- [`/v1/read/intelligence`](/reference/read/intelligence) takes it as input


---
title: "IntelligenceLayer"
description: "one of the 28 kinds, with its mechanism, what goes in and out, what it assumes, how it fails, and the reading that would show it wrong"
section: concepts
address: /concepts/intelligencelayer
contract: 0476e35e6e275db5
---

# IntelligenceLayer

one of the 28 kinds, with its mechanism, what goes in and out, what it assumes, how it fails, and the reading that would show it wrong

[figure: IntelligenceLayer is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | its name |
| store | postgres |
| family | models |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `kind` | `text` | yes | from the register of 28 |
| `mechanism` | `one of a proxy \| a summary over the record \| deciding identity \| a derived graph \| an estimator \| a cut into groups` | yes |  |
| `goes_in` | [Kind](/concepts/kind) | yes |  |
| `comes_out` | [Kind](/concepts/kind) | yes |  |
| `assumes` | `text` | yes |  |
| `fails` | `text` | yes |  |
| `would_show_it_wrong` | `text` | yes |  |
| `state` | [Readiness](/concepts/readiness) | yes |  |



## Routes that use it
No route takes or returns IntelligenceLayer directly. The record holds it, and the objects that point at it reach it.


---
title: "Interval"
description: "a point with its interval"
section: concepts
address: /concepts/interval
contract: 0476e35e6e275db5
---

# Interval

a point with its interval

[figure: Interval is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | kernel |



## Fields


| field | type | required | note |
|---|---|---|---|
| `point` | `json` | yes | a number, a money or a count |
| `lower` | `json` | yes |  |
| `upper` | `json` | yes |  |
| `level` | `share` | yes | the coverage of the interval, checked |



## Routes that use it
No route takes or returns Interval directly. The record holds it, and the objects that point at it reach it.


---
title: "Intervention"
description: "what a play does to a systems model: a change to one flow's rate, delay, inflow, outflow or limit, from a stated step of the horizon"
section: concepts
address: /concepts/intervention
contract: 0476e35e6e275db5
---

# Intervention

what a play does to a systems model: a change to one flow's rate, delay, inflow, outflow or limit, from a stated step of the horizon

[figure: Intervention is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `play` | `id` | no | the play that makes it, where one is armed |
| `tactic` | [Tactic](/concepts/tactic) | no | the tactic it applies |
| `on_flow` | `text` | yes |  |
| `changes` | `one of rate \| delay \| inflow \| outflow \| limit \| payoff` | yes |  |
| `by` | [DriverNode](/concepts/drivernode) | yes | the change, as a tree over drivers |
| `since` | `duration` | no | when in the horizon it starts |
| `kind_of_play` | [KindOfPlay](/concepts/kindofplay) | no | the kind of play the intervention stands for |



## Routes that use it
No route takes or returns Intervention directly. The record holds it, and the objects that point at it reach it.


---
title: "Invitation"
description: "a person invited by address to a role of the tenant, bound when they sign in with that address"
section: concepts
address: /concepts/invitation
contract: 0476e35e6e275db5
---

# Invitation

a person invited by address to a role of the tenant, bound when they sign in with that address

[figure: Invitation is a definition at tenant scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | tenant |
| key | the tenant and the address |
| store | postgres |
| family | people |



## Fields


| field | type | required | note |
|---|---|---|---|
| `tenant` | `id` | yes |  |
| `address` | `text` | yes |  |
| `role` | `text` | yes |  |
| `invited_by` | `id` | yes |  |
| `expires` | `time` | yes |  |
| `standing` | `one of open \| accepted \| expired \| withdrawn` | yes |  |
| `held_on` | [Scope](/concepts/scope) | no | the tenant, brand or strategy the role is held on once accepted; a guest's invitation names a brand |



## Routes that use it
- [`/v1/act/invite`](/reference/act/invite) returns it


---
title: "InviteInput"
description: "an address and a role to invite to the tenant, with where the role is held"
section: concepts
address: /concepts/inviteinput
contract: 0476e35e6e275db5
---

# InviteInput

an address and a role to invite to the tenant, with where the role is held

[figure: InviteInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `address` | `text` | yes |  |
| `role` | `text` | yes |  |
| `held_on` | [Scope](/concepts/scope) | no | the tenant, brand or strategy the role is held on; absent means the whole tenant, which a guest may not hold (a guest holds roles only on the brands they were invited to) |



## Routes that use it
- [`/v1/act/invite`](/reference/act/invite) takes it as input


---
title: "Invoice"
description: "one invoice: the lines by kind of usage from the metered rows, the fee, the amount recomputed from the record, the provider's id and the state"
section: concepts
address: /concepts/invoice
contract: 0476e35e6e275db5
---

# Invoice

one invoice: the lines by kind of usage from the metered rows, the fee, the amount recomputed from the record, the provider's id and the state

[figure: Invoice is a fact at tenant scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | tenant |
| key | the tenant and the period |
| store | postgres |
| family | operations |



## Fields


| field | type | required | note |
|---|---|---|---|
| `period` | [Window](/concepts/window) | yes |  |
| `lines` | `[json]` | yes | kind, quantity, price, amount |
| `fee` | `money` | yes |  |
| `amount` | `money` | yes | recomputed from the rows |
| `currency` | `text` | yes |  |
| `provider_invoice_id` | `text` | no |  |
| `state` | `one of draft \| issued \| paid \| failed \| void` | yes |  |



## Routes that use it
No route takes or returns Invoice directly. The record holds it, and the objects that point at it reach it.


---
title: "InvoicesInput"
description: "the period of the invoices to read, or all"
section: concepts
address: /concepts/invoicesinput
contract: 0476e35e6e275db5
---

# InvoicesInput

the period of the invoices to read, or all

[figure: InvoicesInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `period` | [Window](/concepts/window) | no |  |



## Routes that use it
- [`/v1/read/invoices`](/reference/read/invoices) takes it as input


---
title: "Item"
description: "the atomic unit of input and output on the wire, typed by kind, with a lifecycle of started, streaming and completed; a tool call completes with its response card"
section: concepts
address: /concepts/item
contract: 0476e35e6e275db5
---

# Item

the atomic unit of input and output on the wire, typed by kind, with a lifecycle of started, streaming and completed; a tool call completes with its response card

[figure: Item is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `id` | `id` | yes |  |
| `kind` | `one of user-message \| agent-message \| tool-call \| task \| approval-request \| question \| notification \| document` | yes |  |
| `state` | `one of started \| streaming \| completed` | yes |  |
| `payload` | `json` | yes | the owning type of the kind: UserMessage for a user-message, ToolCall for a tool-call, Task for a task, ApprovalRequest, TaskQuestion, Notification and Document for theirs; never a shape made at the site |
| `started_at` | `time` | yes |  |
| `completed_at` | `time` | no |  |



## Routes that use it
No route takes or returns Item directly. The record holds it, and the objects that point at it reach it.


---
title: "Job"
description: "one run of a way in the acquisition system or the connector host"
section: concepts
address: /concepts/job
contract: 0476e35e6e275db5
---

# Job

one run of a way in the acquisition system or the connector host

[figure: Job is a work at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | work |
| scope | follows |
| key | the key the platform made from the ask |
| store | acquisition |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `asks` | `[id]` | yes |  |
| `way` | [AccessMethod](/concepts/accessmethod) | yes |  |
| `host` | `text` | yes |  |
| `hops` | [HopStamp](/concepts/hopstamp) | yes |  |
| `failure` | [FailureClass](/concepts/failureclass) | no |  |
| `lease` | `id` | no |  |



## Routes that use it
- [`/v1/work/backfill`](/reference/work/backfill) returns it


---
title: "Journey"
description: "every hop of one unit, walked from its id alone, with a bound on depth"
section: concepts
address: /concepts/journey
contract: 0476e35e6e275db5
---

# Journey

every hop of one unit, walked from its id alone, with a bound on depth

[figure: Journey is a view at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | none |
| key | one unit |
| store | derived |
| family | ops_console |



## Fields


| field | type | required | note |
|---|---|---|---|
| `unit` | `id` | yes |  |
| `hops` | [Event](/concepts/event) | yes |  |
| `back_to` | `[id]` | yes | the artefact and the source |
| `forward_to` | `[id]` | yes | the lead |
| `stopped_at_bound` | `bool` | yes |  |



## Routes that use it
- [`/v1/view/journey`](/reference/view/journey) returns it


---
title: "JourneyInput"
description: "one unit, and a bound on depth"
section: concepts
address: /concepts/journeyinput
contract: 0476e35e6e275db5
---

# JourneyInput

one unit, and a bound on depth

[figure: JourneyInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `unit` | [UnitRef](/concepts/unitref) | yes |  |
| `depth` | `count` | no |  |



## Routes that use it
- [`/v1/view/journey`](/reference/view/journey) takes it as input


---
title: "JudgeFitInput"
description: "a kind of buyer and an entity to judge, without making a lead"
section: concepts
address: /concepts/judgefitinput
contract: 0476e35e6e275db5
---

# JudgeFitInput

a kind of buyer and an entity to judge, without making a lead

[figure: JudgeFitInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `kind_of_buyer` | `id` | yes |  |
| `entity` | `id` | yes |  |
| `brand` | `id` | no |  |



## Routes that use it
- [`/v1/ask/judge_fit`](/reference/ask/judge_fit) takes it as input


---
title: "KeepBasketInput"
description: "a basket to keep"
section: concepts
address: /concepts/keepbasketinput
contract: 0476e35e6e275db5
---

# KeepBasketInput

a basket to keep

[figure: KeepBasketInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `basket` | [ProxyBasket](/concepts/proxybasket) | yes |  |



## Routes that use it
- [`/v1/act/keep_basket`](/reference/act/keep_basket) takes it as input


---
title: "KeepBuyerInput"
description: "a buyer profile as it should stand next: its own predicate in full, its bindings and its ladder; the platform compiles the predicate, keeps it by its hash, and writes the next version ready or not ready with the reason"
section: concepts
address: /concepts/keepbuyerinput
contract: 0476e35e6e275db5
---

# KeepBuyerInput

a buyer profile as it should stand next: its own predicate in full, its bindings and its ladder; the platform compiles the predicate, keeps it by its hash, and writes the next version ready or not ready with the reason

[figure: KeepBuyerInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `kind_of_buyer` | [KindOfBuyer](/concepts/kindofbuyer) | yes | the whole profile, with the predicate's tree given in full |



## Routes that use it
- [`/v1/act/keep_buyer`](/reference/act/keep_buyer) takes it as input


---
title: "KeepLadderInput"
description: "a ladder to keep: its ordered rungs, each a predicate over the population that is kept by its hash in the same call, and the rung that qualifies"
section: concepts
address: /concepts/keepladderinput
contract: 0476e35e6e275db5
---

# KeepLadderInput

a ladder to keep: its ordered rungs, each a predicate over the population that is kept by its hash in the same call, and the rung that qualifies

[figure: KeepLadderInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `ladder` | [Ladder](/concepts/ladder) | yes | the rungs carry their predicates by hash; a rung whose predicate is given in full under `predicates` is kept first |
| `predicates` | [Predicate](/concepts/predicate) | no | the rungs' predicates in full, kept by their hashes before the ladder |



## Routes that use it
- [`/v1/act/keep_ladder`](/reference/act/keep_ladder) takes it as input


---
title: "KeepMonitorInput"
description: "a monitor to keep: its name, its predicate, the place it runs at and the kind of signal it makes; the strategy where one is chosen, else the brand's standing strategy; for a platform monitor the vertical it keeps full"
section: concepts
address: /concepts/keepmonitorinput
contract: 0476e35e6e275db5
---

# KeepMonitorInput

a monitor to keep: its name, its predicate, the place it runs at and the kind of signal it makes; the strategy where one is chosen, else the brand's standing strategy; for a platform monitor the vertical it keeps full

[figure: KeepMonitorInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `predicate` | [Predicate](/concepts/predicate) | yes | the tree, compiled at the place |
| `place` | [PlaceARunsAt](/concepts/placearunsat) | yes |  |
| `kind_of_signal` | [KindOfSignal](/concepts/kindofsignal) | yes |  |
| `strategy` | `id` | no | the brand's standing strategy unless one is chosen |
| `vertical` | `text` | no | for a platform monitor |



## Routes that use it
- [`/v1/act/keep_monitor`](/reference/act/keep_monitor) takes it as input


---
title: "KeepPlayInput"
description: "a play to keep for a brand: the play with its condition and its graph of moves as edges, and the predicates given in full, kept by their hashes before the play"
section: concepts
address: /concepts/keepplayinput
contract: 0476e35e6e275db5
---

# KeepPlayInput

a play to keep for a brand: the play with its condition and its graph of moves as edges, and the predicates given in full, kept by their hashes before the play

[figure: KeepPlayInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `play` | [Play](/concepts/play) | yes | its condition and its edges carry their predicates by hash; a predicate given in full under `predicates` is kept first |
| `predicates` | [Predicate](/concepts/predicate) | no | the condition's and the edges' predicates in full, kept by their hashes before the play |



## Routes that use it
- [`/v1/act/keep_play`](/reference/act/keep_play) takes it as input


---
title: "KeepProxyInput"
description: "a proxy to keep"
section: concepts
address: /concepts/keepproxyinput
contract: 0476e35e6e275db5
---

# KeepProxyInput

a proxy to keep

[figure: KeepProxyInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `proxy` | [Proxy](/concepts/proxy) | yes |  |



## Routes that use it
- [`/v1/act/keep_proxy`](/reference/act/keep_proxy) takes it as input


---
title: "KeepQuestionInput"
description: "the question and its scope"
section: concepts
address: /concepts/keepquestioninput
contract: 0476e35e6e275db5
---

# KeepQuestionInput

the question and its scope

[figure: KeepQuestionInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `question` | [SavedQuestion](/concepts/savedquestion) | yes |  |



## Routes that use it
- [`/v1/ask/keep_question`](/reference/ask/keep_question) takes it as input


---
title: "Key"
description: "a second kind of caller: a key with an identity of its own"
section: concepts
address: /concepts/key
contract: 0476e35e6e275db5
---

# Key

a second kind of caller: a key with an identity of its own

[figure: Key is a definition at tenant scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | tenant |
| key | its id |
| store | postgres |
| family | people |



## Fields


| field | type | required | note |
|---|---|---|---|
| `owner` | `one of the platform \| a tenant` | yes |  |
| `acts_for` | `id` | yes | the one person or service it may act for |
| `scopes` | [Scope](/concepts/scope) | yes |  |
| `access_scopes` | [AccessScope](/concepts/accessscope) | yes |  |
| `mode` | `one of read only \| propose \| act \| full autonomy` | yes |  |
| `ends_at` | `time` | no |  |
| `withdrawn_at` | `time` | no |  |



## Routes that use it
No route takes or returns Key directly. The record holds it, and the objects that point at it reach it.


---
title: "KeyFitness"
description: "how often a key is present, and how often two different things share a value"
section: concepts
address: /concepts/keyfitness
contract: 0476e35e6e275db5
---

# KeyFitness

how often a key is present, and how often two different things share a value

[figure: KeyFitness is a fact at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | platform |
| key | the kind, the namespace and the window |
| store | postgres |
| family | identity |



## Fields


| field | type | required | note |
|---|---|---|---|
| `kind` | [KindOfEntity](/concepts/kindofentity) | yes |  |
| `namespace` | `text` | yes |  |
| `window` | [Window](/concepts/window) | yes |  |
| `present_share` | `share` | yes |  |
| `shared_share` | `share` | yes |  |



## Routes that use it
No route takes or returns KeyFitness directly. The record holds it, and the objects that point at it reach it.


---
title: "KeyRank"
description: "one namespace of identifier, its rank of trust and the sources that supply it"
section: concepts
address: /concepts/keyrank
contract: 0476e35e6e275db5
---

# KeyRank

one namespace of identifier, its rank of trust and the sources that supply it

[figure: KeyRank is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | identity |



## Fields


| field | type | required | note |
|---|---|---|---|
| `namespace` | `text` | yes |  |
| `rank` | `count` | yes |  |
| `sources` | [Source](/concepts/source) | yes |  |
| `may_decide_same` | `bool` | yes |  |
| `shared_by_design` | `bool` | yes | a value shared by design is never a key |



## Routes that use it
No route takes or returns KeyRank directly. The record holds it, and the objects that point at it reach it.


---
title: "Kind"
description: "a kind, as a row of the register of kinds"
section: concepts
address: /concepts/kind
contract: 0476e35e6e275db5
---

# Kind

a kind, as a row of the register of kinds

[figure: Kind is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | its name |
| store | postgres |
| family | kernel |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `type` | `one of fact \| work \| entity \| definition \| view \| value \| parameter \| row` | yes |  |
| `places` | [Place](/concepts/place) | yes | for work: its closed list of places |
| `scope` | `one of shared \| platform \| tenant \| brand \| strategy \| user` | yes | the widest scope a unit of the kind may live at |
| `plane_bound` | `bool` | yes | whether a unit of the kind carries a plane |
| `who_may_write` | [Permission](/concepts/permission) | yes | the permissions that allow a write |
| `class_of_data` | `one of public \| a tenant's own \| about a person \| about a person's condition` | yes |  |
| `retention_class` | [RetentionClass](/concepts/retentionclass) | yes | a kind with no class cannot register |
| `same_by_construction` | `bool` | yes | whether its key is made from its input |
| `version_of_shape` | `count` | yes |  |



## Routes that use it
No route takes or returns Kind directly. The record holds it, and the objects that point at it reach it.


---
title: "KindOfAction"
description: "one kind of action a connector declares, with its reach and its inverse"
section: concepts
address: /concepts/kindofaction
contract: 0476e35e6e275db5
---

# KindOfAction

one kind of action a connector declares, with its reach and its inverse

[figure: KindOfAction is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | the connector and its name |
| store | postgres |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `connector` | [Connector](/concepts/connector) | yes |  |
| `name` | `text` | yes |  |
| `reach` | `one of reads only \| writes to the tenant's own system \| speaks as the brand \| spends money outside \| sends to a person` | yes |  |
| `arguments` | [ArgumentDeclaration](/concepts/argumentdeclaration) | yes |  |
| `inverse` | `text` | no | how it is undone, captured first |
| `identity_needed` | `text` | yes |  |
| `cost` | [Cost](/concepts/cost) | no |  |
| `state` | [Readiness](/concepts/readiness) | yes |  |



## Routes that use it
No route takes or returns KindOfAction directly. The record holds it, and the objects that point at it reach it.


---
title: "KindOfBuyer"
description: "a kind of customer a brand sells to, written as a predicate so its members can be counted; it compiles or it is not ready"
section: concepts
address: /concepts/kindofbuyer
contract: 0476e35e6e275db5
---

# KindOfBuyer

a kind of customer a brand sells to, written as a predicate so its members can be counted; it compiles or it is not ready

[figure: KindOfBuyer is a definition at brand scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | brand |
| key | its name and version |
| store | postgres |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `sentence` | `text` | yes |  |
| `predicate` | [Predicate](/concepts/predicate) | yes |  |
| `bindings` | [Binding](/concepts/binding) | yes |  |
| `ladder` | `id` | yes |  |
| `motives` | [Motive](/concepts/motive) | no | each kind of motive with its evidence; wants and puts-off are two of the kinds |
| `who_else_must_agree` | [RoleAroundADecision](/concepts/rolearoundadecision) | no |  |
| `preview` | [PreviewAnswer](/concepts/previewanswer) | no | the last |
| `hypothesis` | `id` | no |  |
| `original` | `id` | no | the template's original |
| `fingerprint` | [Predicate](/concepts/predicate) | no | the definition that finds members of the kind over communities, utterances and likeness; a kind without one is not ready |
| `found_in` | [UnitRef](/concepts/unitref) | no | the communities where its members are found, with the lift on the audience map |
| `leads_to` | [LeadsTo](/concepts/leadsto) | no | the kinds this kind brings, becomes or crosses to, with the rate |
| `economics` | [EconomicReading](/concepts/economicreading) | no | numbers about the kind that are not a count of members, each in its own position |
| `reached_through` | [RouteToBuyer](/concepts/routetobuyer) | no | the routes to the buyer that are not communities |
| `filed_under` | [UnitRef](/concepts/unitref) | no | a family, a vertical, an application or a chain stock |
| `basket` | `id` | no | the proxies its fingerprint names, kept as a basket |



## Routes that use it
- [`/v1/act/keep_buyer`](/reference/act/keep_buyer) returns it


---
title: "KindOfConnection"
description: "a kind of connection, as a row: its roles and what each role allows"
section: concepts
address: /concepts/kindofconnection
contract: 0476e35e6e275db5
---

# KindOfConnection

a kind of connection, as a row: its roles and what each role allows

[figure: KindOfConnection is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | its name |
| store | postgres |
| family | record |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `roles` | [ConnectionRole](/concepts/connectionrole) | yes |  |
| `from_header` | [HeaderRule](/concepts/headerrule) | no | the rule that makes this kind of connection from the shared silver header, when the kind has one: each role bound to a header column, and when the rule applies; a kind with no rule makes no view |
| `adds` | [SourceField](/concepts/sourcefield) | no | the fields the kind adds, typed as a source object declares its fields; each is a typed column of the kind's gold table |
| `layer` | `one of relational \| associative \| semantic \| none` | yes | the layer of likeness it feeds, if any |
| `materialised_under_a_cut` | `bool` | yes | for co-presence |
| `symmetric` | `bool` | no |  |
| `transitive` | `bool` | no | a derivation may walk it to a depth only when true |
| `inverse_of` | [KindOfConnection](/concepts/kindofconnection) | no |  |



## Routes that use it
No route takes or returns KindOfConnection directly. The record holds it, and the objects that point at it reach it.


---
title: "KindOfEntity"
description: "a kind of entity, with its keys in order of trust and what may never be merged"
section: concepts
address: /concepts/kindofentity
contract: 0476e35e6e275db5
---

# KindOfEntity

a kind of entity, with its keys in order of trust and what may never be merged

[figure: KindOfEntity is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | its name |
| store | postgres |
| family | identity |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `keys` | [KeyRank](/concepts/keyrank) | yes | most authoritative first |
| `never_merged` | `[text]` | yes | a law, as rows |
| `parent_kind` | [KindOfEntity](/concepts/kindofentity) | no |  |
| `kept_once` | `bool` | yes | or a tenant's |
| `core_set` | `bool` | yes |  |



## Routes that use it
No route takes or returns KindOfEntity directly. The record holds it, and the objects that point at it reach it.


---
title: "KindOfFraming"
description: "a way a sale is framed, a register a person extends by a row: mechanistic, emotional, motivational, social proof, risk and loss, time and urgency, status, curiosity, authority, belonging, reciprocity, scarcity, simplicity, craft, and more"
section: concepts
address: /concepts/kindofframing
contract: 0476e35e6e275db5
---

# KindOfFraming

a way a sale is framed, a register a person extends by a row: mechanistic, emotional, motivational, social proof, risk and loss, time and urgency, status, curiosity, authority, belonging, reciprocity, scarcity, simplicity, craft, and more

[figure: KindOfFraming is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | its name |
| store | postgres |
| family | strategy |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `order` | `count` | yes |  |
| `appeals_to` | `text` | yes | what in the buyer it speaks to |
| `needs` | `text` | yes | the evidence from the buyer it needs before it is chosen |



## Routes that use it
No route takes or returns KindOfFraming directly. The record holds it, and the objects that point at it reach it.


---
title: "KindOfMarketEvent"
description: "a kind of market event"
section: concepts
address: /concepts/kindofmarketevent
contract: 0476e35e6e275db5
---

# KindOfMarketEvent

a kind of market event

[figure: KindOfMarketEvent is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | its name |
| store | postgres |
| family | record |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `adds` | [SourceField](/concepts/sourcefield) | no | the fields the kind adds, typed; each is a typed column of the kind's gold table |
| `named_in` | `[text]` | no | the pages or specifications that name it |



## Routes that use it
No route takes or returns KindOfMarketEvent directly. The record holds it, and the objects that point at it reach it.


---
title: "KindOfMeasure"
description: "a registered kind of measure"
section: concepts
address: /concepts/kindofmeasure
contract: 0476e35e6e275db5
---

# KindOfMeasure

a registered kind of measure

[figure: KindOfMeasure is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | its name |
| store | postgres |
| family | registers |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `dimension` | `text` | yes | the unit and the value's type, from the closed list of SourceField types, so the measure's gold column is typed |
| `definition_version` | `count` | yes |  |
| `instrument` | `text` | yes |  |
| `read_with_nothing_connected` | `bool` | yes |  |
| `slices` | `[text]` | no | the registered dimensions a reading may be cut by: a rail, a band, an hour, a list position |
| `page_words` | `[text]` | no | the words a page shows beside a count of this measure, singular and plural, so a reader finds the count on any page |
| `family` | `text` | no | the family a measure belongs to: economics for a value driver, else absent |
| `stated_by` | `one of the buyer \| a benchmark \| the record \| a formula` | no | for a value driver: who supplies its number |
| `question` | `text` | no | for a value driver the buyer states: the question in the buyer's own words |
| `bounds` | [Interval](/concepts/interval) | no | for a value driver the buyer states: the floor and the ceiling a stated value may not cross |



## Routes that use it
No route takes or returns KindOfMeasure directly. The record holds it, and the objects that point at it reach it.


---
title: "KindOfMotive"
description: "a registered kind of motive a buyer or a router carries: what they want, what puts them off, the pain, the trigger, the job to be done, the proof they accept, the number they judge success by, the first need, and what makes them commit or stay"
section: concepts
address: /concepts/kindofmotive
contract: 0476e35e6e275db5
---

# KindOfMotive

a registered kind of motive a buyer or a router carries: what they want, what puts them off, the pain, the trigger, the job to be done, the proof they accept, the number they judge success by, the first need, and what makes them commit or stay

[figure: KindOfMotive is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | its name |
| store | postgres |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes | the platform's rows: want, put-off, pain, trigger, job to be done, proof accepted, success measure, first need, commits or stays, constraint, how they buy; a new kind is a row, never a change to the register |
| `order` | `count` | yes |  |



## Routes that use it
No route takes or returns KindOfMotive directly. The record holds it, and the objects that point at it reach it.


---
title: "KindOfMove"
description: "one kind of move a play proposes: what it does, how far its actions reach, how it is read, the class it usually reads, the play families it serves, whether it routes an actor and carries content"
section: concepts
address: /concepts/kindofmove
contract: 0476e35e6e275db5
---

# KindOfMove

one kind of move a play proposes: what it does, how far its actions reach, how it is read, the class it usually reads, the play families it serves, whether it routes an actor and carries content

[figure: KindOfMove is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | its name |
| store | postgres |
| family | strategy |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `does` | `text` | yes |  |
| `reach` | `text` | yes | how far its actions reach, in the words of the kinds of action |
| `how_read` | `text` | yes | the measure that reads it |
| `usual_class` | [PlayClass](/concepts/playclass) | yes |  |
| `families` | `[one of demand engineering \| demand capture \| channel and partnership \| pricing \| positioning and proof \| offering design \| market entry and beachhead \| growth in a market \| retention and existing customers \| competitive \| regulatory and payer \| education and enablement \| sales motion and operations \| hedge and portfolio \| ecosystem and platform]` | yes | the play families it serves |
| `routes_an_actor` | `bool` | yes | true when the move is carried by a person, a voice or a held identity chosen by propensity |
| `carries_content` | `bool` | yes | true when the move carries content chosen by propensity |
| `example` | `text` | yes | from the work by hand |



## Routes that use it
No route takes or returns KindOfMove directly. The record holds it, and the objects that point at it reach it.


---
title: "KindOfOffering"
description: "one of the shapes an offering is sold in, so a tactic and a systems model can say which kinds they apply to"
section: concepts
address: /concepts/kindofoffering
contract: 0476e35e6e275db5
---

# KindOfOffering

one of the shapes an offering is sold in, so a tactic and a systems model can say which kinds they apply to

[figure: KindOfOffering is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | its name |
| store | postgres |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `what` | `text` | yes |  |
| `sold_as` | `one of subscription \| retainer \| project \| goods \| usage \| licence \| marketplace take \| placement` | yes | how money moves for this kind |
| `unit_of_sale` | `text` | yes | the unit a price attaches to |
| `examples` | `[text]` | yes |  |



## Routes that use it
No route takes or returns KindOfOffering directly. The record holds it, and the objects that point at it reach it.


---
title: "KindOfPlay"
description: "one kind of play a strategy may run in a market: its family, what it does, the mechanism it works by, what it changes on the living market's model (which flow, loop, stock or payoff, and how), the number that decides it with its control, its known failure, the phases of the search it serves, the ways of going to…"
section: concepts
address: /concepts/kindofplay
contract: 0476e35e6e275db5
---

# KindOfPlay

one kind of play a strategy may run in a market: its family, what it does, the mechanism it works by, what it changes on the living market's model (which flow, loop, stock or payoff, and how), the number that decides it with its control, its known failure, the phases of the search it serves, the ways of going to…

[figure: KindOfPlay is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | its name |
| store | postgres |
| family | strategy |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `family` | `one of demand engineering \| demand capture \| channel and partnership \| pricing \| positioning and proof \| offering design \| market entry and beachhead \| growth in a market \| retention and existing customers \| competitive \| regulatory and payer \| education and enablement \| sales motion and operations \| hedge and portfolio \| ecosystem and platform` | yes |  |
| `what` | `text` | yes | what the play does, in one sentence |
| `mechanism` | `text` | yes | how it works, in the field's terms |
| `changes` | `one of the rate of a flow \| the delay of a flow \| the inflow of a stock \| the outflow of a stock \| the limit of a loop \| a payoff of a role \| a handover's count \| a stock's reader` | yes | what it changes on the model |
| `on` | `text` | yes | which flow, loop, stock, handover or role it changes, in the template's words |
| `deciding_number` | `text` | yes | the number that says it worked, and its bar |
| `control` | `text` | yes | the control read in the same run |
| `known_failure` | `text` | yes | the way it goes wrong, and the answer |
| `phases` | `[one of find the market \| sculpt the offering \| test the fit \| build a beachhead \| engineer demand \| find demand \| grow in a market \| hedge]` | yes | the phases of the search it serves |
| `ways` | [WayOfGoingToMarket](/concepts/wayofgoingtomarket) | yes | the ways of going to market it fits; empty means every way |
| `kinds_of_offering` | [KindOfOffering](/concepts/kindofoffering) | yes | empty means every kind |
| `roles_moved` | [RoleAroundADecision](/concepts/rolearoundadecision) | yes | the roles whose decision it moves |
| `usual_class` | `one of table stakes \| alpha \| expansion \| hedge \| depends on the rivals` | yes | the class it usually reads against the rivals' coverage (DOMAIN/10 section 2); read, never assumed, when a play is armed |
| `counter_play` | `text` | no | the play a rival makes in answer, where the field knows one |
| `tactics` | [Tactic](/concepts/tactic) | no | the tactics of the catalogue that run it, where they exist |



## Routes that use it
No route takes or returns KindOfPlay directly. The record holds it, and the objects that point at it reach it.


---
title: "KindOfPlayObserved"
description: "a brand observed running a kind of play, with the evidence that showed it: the rivals' coverage of a kind of play is the count of rival brands with a standing observation of it; written by the brand graph's build from a domain (WORK-AHEAD row ) or by a person who marks it"
section: concepts
address: /concepts/kindofplayobserved
contract: 0476e35e6e275db5
---

# KindOfPlayObserved

a brand observed running a kind of play, with the evidence that showed it: the rivals' coverage of a kind of play is the count of rival brands with a standing observation of it; written by the brand graph's build from a domain (WORK-AHEAD row ) or by a person who marks it

[figure: KindOfPlayObserved is a fact at brand scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | brand |
| key | the brand, the kind of play and the evidence |
| store | postgres |
| family | strategy |



## Fields


| field | type | required | note |
|---|---|---|---|
| `brand` | `id` | yes |  |
| `kind_of_play` | [KindOfPlay](/concepts/kindofplay) | yes |  |
| `evidence` | [EvidenceRef](/concepts/evidenceref) | yes | what showed it: a page, a post, a filing |
| `withdrawn_by` | `id` | no | a correction that ended the observation |



## Routes that use it
No route takes or returns KindOfPlayObserved directly. The record holds it, and the objects that point at it reach it.


---
title: "KindOfReading"
description: "one kind of reading a connector declares, ready only after the check against recorded samples"
section: concepts
address: /concepts/kindofreading
contract: 0476e35e6e275db5
---

# KindOfReading

one kind of reading a connector declares, ready only after the check against recorded samples

[figure: KindOfReading is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | the connector and the way |
| store | postgres |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes | One name made from the connector and the way. The connector's declares lists this name. |
| `connector` | [Connector](/concepts/connector) | yes |  |
| `way` | [AccessMethod](/concepts/accessmethod) | yes |  |
| `returns` | [SourceObject](/concepts/sourceobject) | yes |  |
| `depth` | `text` | yes |  |
| `cadence_allowed` | `duration` | yes |  |
| `rights` | [Rights](/concepts/rights) | yes |  |
| `probe` | `bool` | yes |  |
| `subscribes` | `bool` | yes | the source's own feed of changes |
| `backfills` | `bool` | yes | a window of history in blocks |
| `samples_checked_at` | `time` | no |  |
| `state` | [Readiness](/concepts/readiness) | yes |  |



## Routes that use it
No route takes or returns KindOfReading directly. The record holds it, and the objects that point at it reach it.


---
title: "KindOfSignal"
description: "a kind of signal: what it means, its population, its sources, and a floor for each of the four numbers of strength"
section: concepts
address: /concepts/kindofsignal
contract: 0476e35e6e275db5
---

# KindOfSignal

a kind of signal: what it means, its population, its sources, and a floor for each of the four numbers of strength

[figure: KindOfSignal is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | its name |
| store | postgres |
| family | rules_engine |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `meaning` | `text` | yes |  |
| `population` | [Population](/concepts/population) | no | required before the kind is ready; absent while it is not ready with that reason |
| `sources` | [Source](/concepts/source) | yes | the kinds of source that can show it |
| `floors` | [ProxyStrength](/concepts/proxystrength) | no | required before the kind is ready; absent while it is not ready with that reason |
| `stage` | [Stage](/concepts/stage) | no |  |
| `state` | [Readiness](/concepts/readiness) | yes | not ready when no ready monitor and no ready source can make it |
| `evaluation` | `one of an event lands \| a count over a window \| a change between readings \| a rate against a baseline \| made true by time passing \| an ordered sequence \| a meaning or phrase match \| an overlap between populations \| a join through a place or segment \| the tenant's own facts \| derived by a rule \| a membership or fit` | yes | the way it is evaluated, which decides the layout it needs |
| `aliases` | `[text]` | no | other names for the same kind, merged by the seed |
| `named_in` | `[text]` | no | the pages that name it |



## Routes that use it
No route takes or returns KindOfSignal directly. The record holds it, and the objects that point at it reach it.


---
title: "KindOfUsage"
description: "one kind of metered usage with its unit, its price basis and its provider: network egress, proxy bytes, model tokens, embedding calls, image generation, document storage, lakehouse bytes, browser minutes, search queries, connector calls, downloads"
section: concepts
address: /concepts/kindofusage
contract: 0476e35e6e275db5
---

# KindOfUsage

one kind of metered usage with its unit, its price basis and its provider: network egress, proxy bytes, model tokens, embedding calls, image generation, document storage, lakehouse bytes, browser minutes, search queries, connector calls, downloads

[figure: KindOfUsage is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | its name |
| store | postgres |
| family | operations |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `unit` | `text` | yes | bytes, tokens, calls, minutes, queries, images |
| `provider` | `text` | no | a provider row: DeepSeek, Modal, the proxy provider, the object store |
| `price_basis` | `one of list price \| the provider's bill \| estimated` | yes |  |
| `ceiling` | [Cost](/concepts/cost) | no | of the receive family |



## Routes that use it
No route takes or returns KindOfUsage directly. The record holds it, and the objects that point at it reach it.


---
title: "KnownExamples"
description: "labelled pairs or items in both directions, kept apart from the audit's samples"
section: concepts
address: /concepts/knownexamples
contract: 0476e35e6e275db5
---

# KnownExamples

labelled pairs or items in both directions, kept apart from the audit's samples

[figure: KnownExamples is a fact at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | platform |
| key | the model, the version and the date |
| store | postgres |
| family | models |



## Fields


| field | type | required | note |
|---|---|---|---|
| `model` | [Model](/concepts/model) | yes |  |
| `items` | `count` | yes |  |
| `labelled_by` | `text` | yes |  |
| `how` | `text` | yes |  |
| `both_directions` | `bool` | yes |  |
| `path` | `text` | yes |  |



## Routes that use it
No route takes or returns KnownExamples directly. The record holds it, and the objects that point at it reach it.


---
title: "Ladder"
description: "ordered rungs, each written as the rung below with further conditions"
section: concepts
address: /concepts/ladder
contract: 0476e35e6e275db5
---

# Ladder

ordered rungs, each written as the rung below with further conditions

[figure: Ladder is a definition at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | follows |
| key | the brand or the vertical, and its name |
| store | postgres |
| family | rules_engine |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `rungs` | [Rung](/concepts/rung) | yes |  |
| `qualifying_rung` | `text` | yes | the template's default, changeable by the brand |
| `original` | `id` | no |  |



## Routes that use it
- [`/v1/act/keep_ladder`](/reference/act/keep_ladder) returns it


---
title: "LadderInput"
description: "the ladder in force, or one version"
section: concepts
address: /concepts/ladderinput
contract: 0476e35e6e275db5
---

# LadderInput

the ladder in force, or one version

[figure: LadderInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | one ask for the ladder |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `version` | `count` | no |  |



## Routes that use it
- [`/v1/economics/ladder`](/reference/economics/ladder) takes it as input


---
title: "LakeFile"
description: "one file of a partition"
section: concepts
address: /concepts/lakefile
contract: 0476e35e6e275db5
---

# LakeFile

one file of a partition

[figure: LakeFile is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | record |



## Fields


| field | type | required | note |
|---|---|---|---|
| `path` | `text` | yes |  |
| `hash` | `hash` | yes |  |
| `bytes` | `bytes` | yes |  |
| `rows` | `count` | yes |  |
| `modified` | `time` | no | when the file last changed, as the file system reports it; a reader hashes a file again only when its bytes or this time moved, so a reading grows by the files that arrived |



## Routes that use it
No route takes or returns LakeFile directly. The record holds it, and the objects that point at it reach it.


---
title: "LakehouseStore"
description: "the value of the parameter the address of the lakehouse's store: the folder of files, the catalogue's database address without a password, and the prefix of the lakehouse catalogue's schemas, one for each plane"
section: concepts
address: /concepts/lakehousestore
contract: 0476e35e6e275db5
---

# LakehouseStore

the value of the parameter the address of the lakehouse's store: the folder of files, the catalogue's database address without a password, and the prefix of the lakehouse catalogue's schemas, one for each plane

[figure: LakehouseStore is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | record |



## Fields


| field | type | required | note |
|---|---|---|---|
| `folder` | `text` | yes | a folder on a laptop, a bucket on the three machines |
| `catalogue` | `address` | yes | the database that holds the lakehouse catalogue; the password comes from the secrets manager, never from here |
| `catalogue_prefix` | `text` | yes | one schema of the lakehouse catalogue for each plane under this prefix |
| `scratch` | `text` | no | the folder the engine spills to when a read exceeds its memory; a folder named tmp beside the store's folder when absent, never the working folder of the process (read 27 September: 24 GB of spill in the platform's own tree made a release dirty) |



## Routes that use it
No route takes or returns LakehouseStore directly. The record holds it, and the objects that point at it reach it.


---
title: "LandedArtefact"
description: "the artefact as the source gave it, keyed by its content hash"
section: concepts
address: /concepts/landedartefact
contract: 0476e35e6e275db5
---

# LandedArtefact

the artefact as the source gave it, keyed by its content hash

[figure: LandedArtefact is a fact at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | follows |
| key | its content hash |
| store | lake:landed |
| family | record |



## Fields


| field | type | required | note |
|---|---|---|---|
| `bytes_hash` | `hash` | yes |  |
| `bytes` | `bytes` | yes |  |
| `way` | [AccessMethod](/concepts/accessmethod) | yes |  |
| `fetched_at` | `time` | yes |  |
| `ask` | `id` | yes |  |



## Routes that use it
No route takes or returns LandedArtefact directly. The record holds it, and the objects that point at it reach it.


---
title: "LandingOfObservations"
description: "one landing of observations into the tenant plane's gold from what the platform captured and holds: the pages captured whole, and the posts and comments of the corpus tables, each as one observation with its text and its hash, keyed by the row it was made from so a repeat writes nothing"
section: concepts
address: /concepts/landingofobservations
contract: 0476e35e6e275db5
---

# LandingOfObservations

one landing of observations into the tenant plane's gold from what the platform captured and holds: the pages captured whole, and the posts and comments of the corpus tables, each as one observation with its text and its hash, keyed by the row it was made from so a repeat writes nothing

[figure: LandingOfObservations is a work at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | work |
| scope | platform |
| key | the source and the hour |
| store | postgres |
| family | record |



## Fields


| field | type | required | note |
|---|---|---|---|
| `source` | [Source](/concepts/source) | yes |  |
| `read_from` | `text` | yes | the table or the store the observations were read from |
| `rows_read` | `count` | yes |  |
| `observations_written` | `count` | yes |  |
| `already_held` | `count` | yes |  |
| `why_stopped` | `text` | no |  |



## Routes that use it
No route takes or returns LandingOfObservations directly. The record holds it, and the objects that point at it reach it.


---
title: "LanguageScale"
description: "a name and two or more poles, counted over a group's own writing by month; aggregate-only by rule"
section: concepts
address: /concepts/languagescale
contract: 0476e35e6e275db5
---

# LanguageScale

a name and two or more poles, counted over a group's own writing by month; aggregate-only by rule

[figure: LanguageScale is a definition at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | follows |
| key | its name |
| store | postgres |
| family | rules_engine |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `poles` | [Pole](/concepts/pole) | yes |  |
| `aggregate_only` | `bool` | yes | always true |



## Routes that use it
No route takes or returns LanguageScale directly. The record holds it, and the objects that point at it reach it.


---
title: "Law"
description: "a check that can fail, registered against a kind or a flow"
section: concepts
address: /concepts/law
contract: 0476e35e6e275db5
---

# Law

a check that can fail, registered against a kind or a flow

[figure: Law is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | its name |
| store | postgres |
| family | kernel |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `against` | `text` | yes | a kind or a flow |
| `check` | `text` | yes | what it reads and what red is |
| `planted_fault` | `text` | yes | the case that must read red |
| `last_red` | `time` | no |  |
| `last_green` | `time` | no |  |
| `state` | [Readiness](/concepts/readiness) | yes | not trusted until the injected fault fails the check and the restored case passes it |



## Routes that use it
No route takes or returns Law directly. The record holds it, and the objects that point at it reach it.


---
title: "LayerOfLikeness"
description: "the share each of three layers contributed, held apart and never blended"
section: concepts
address: /concepts/layeroflikeness
contract: 0476e35e6e275db5
---

# LayerOfLikeness

the share each of three layers contributed, held apart and never blended

[figure: LayerOfLikeness is a property at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | property |
| scope | none |
| key | none |
| store | none |
| family | models |



## Fields


| field | type | required | note |
|---|---|---|---|
| `relational` | `share` | yes |  |
| `associative` | `share` | yes |  |
| `semantic` | `share` | yes |  |
| `model` | [Model](/concepts/model) | no | for the semantic share |



## Routes that use it
No route takes or returns LayerOfLikeness directly. The record holds it, and the objects that point at it reach it.


---
title: "LayStrategyInput"
description: "a strategy laid over a twin: its armed plays become the interventions of one simulation"
section: concepts
address: /concepts/laystrategyinput
contract: 0476e35e6e275db5
---

# LayStrategyInput

a strategy laid over a twin: its armed plays become the interventions of one simulation

[figure: LayStrategyInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `twin` | `id` | yes |  |
| `strategy` | `id` | yes |  |
| `horizon` | `duration` | no |  |
| `samples` | `count` | no |  |
| `seed` | `count` | no |  |



## Routes that use it
- [`/v1/work/lay_strategy`](/reference/work/lay_strategy) takes it as input


---
title: "Lead"
description: "a candidate that reached the qualifying rung, delivered under the plan's limit or withheld"
section: concepts
address: /concepts/lead
contract: 0476e35e6e275db5
---

# Lead

a candidate that reached the qualifying rung, delivered under the plan's limit or withheld

[figure: Lead is a work at brand scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | work |
| scope | brand |
| key | the entity, the brand and the rung that qualified it |
| store | postgres |
| family | leads |



## Fields


| field | type | required | note |
|---|---|---|---|
| `entity` | `id` | yes |  |
| `person` | `id` | no |  |
| `company` | `id` | no |  |
| `brand` | `id` | yes |  |
| `kind_of_buyer` | `id` | yes |  |
| `candidate` | `id` | yes |  |
| `rung` | `text` | yes |  |
| `definition_versions` | `{text:count}` | yes | of every definition that made it |
| `temperature` | `one of hot \| warm \| cold` | yes | never typed by hand |
| `temperature_reason` | `text` | no | the observation and its age, or the rung |
| `sentence` | `id` | yes | the observation it walks back to |
| `delivered_at` | `time` | no |  |
| `withheld` | [WithheldReason](/concepts/withheldreason) | no |  |
| `assigned_to` | `id` | no |  |
| `outcome` | `id` | no |  |



## Routes that use it
No route takes or returns Lead directly. The record holds it, and the objects that point at it reach it.


---
title: "LeadAssignment"
description: "which user a lead went to, under which rule, who else was eligible, and the odds"
section: concepts
address: /concepts/leadassignment
contract: 0476e35e6e275db5
---

# LeadAssignment

which user a lead went to, under which rule, who else was eligible, and the odds

[figure: LeadAssignment is a fact at brand scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | brand |
| key | the lead and the moment |
| store | postgres |
| family | leads |



## Fields


| field | type | required | note |
|---|---|---|---|
| `lead` | `id` | yes |  |
| `user` | `id` | yes |  |
| `rule` | `id` | no |  |
| `rule_version` | `count` | no |  |
| `eligible` | `[id]` | yes |  |
| `odds` | `chance` | yes |  |
| `by_hand` | [Caller](/concepts/caller) | no |  |
| `missing_input` | `text` | no | said plainly and never invented |



## Routes that use it
- [`/v1/act/assign`](/reference/act/assign) returns it


---
title: "LeadCondition"
description: "something a person can mark on a lead; platform rows, and a tenant's own"
section: concepts
address: /concepts/leadcondition
contract: 0476e35e6e275db5
---

# LeadCondition

something a person can mark on a lead; platform rows, and a tenant's own

[figure: LeadCondition is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | its name and its owner |
| store | postgres |
| family | leads |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `one of replied \| meeting booked \| won \| lost \| not a fit \| wrong person \| do not contact \| a tenant's own` | yes |  |
| `withdraws_consent` | `bool` | yes |  |
| `owner` | `one of the platform \| a tenant` | yes |  |



## Routes that use it
No route takes or returns LeadCondition directly. The record holds it, and the objects that point at it reach it.


---
title: "LeadPass"
description: "one pass of the beat that walks signals to leads: every rung of every kind of buyer bound to a brand run over its population, a candidate made or lifted for each entity a rung admits, judged when it holds what the qualifying rung asks, a lead made from a qualified candidate with its temperature, and each lead…"
section: concepts
address: /concepts/leadpass
contract: 0476e35e6e275db5
---

# LeadPass

one pass of the beat that walks signals to leads: every rung of every kind of buyer bound to a brand run over its population, a candidate made or lifted for each entity a rung admits, judged when it holds what the qualifying rung asks, a lead made from a qualified candidate with its temperature, and each lead…

[figure: LeadPass is a work at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | work |
| scope | platform |
| key | the beat's tick |
| store | postgres |
| family | rules_engine |



## Fields


| field | type | required | note |
|---|---|---|---|
| `kinds_of_buyer` | `count` | yes | bound to a brand and ready |
| `rungs_run` | `count` | yes |  |
| `rungs_not_ready` | `count` | yes | a rung whose predicate is not kept, or does not compile |
| `units_read` | `count` | yes |  |
| `candidates_lifted` | `count` | yes | made or moved up a rung |
| `qualified` | `count` | yes |  |
| `not_a_buyer` | `count` | yes |  |
| `leads_made` | `count` | yes |  |
| `delivered` | `count` | yes |  |
| `withheld` | `count` | yes | at the plan's limit, or with no plan |
| `deferred` | `count` | yes | left for the next tick by the beat's budget |
| `tenants_served` | `count` | yes |  |
| `at` | `time` | yes |  |



## Routes that use it
No route takes or returns LeadPass directly. The record holds it, and the objects that point at it reach it.


---
title: "LeadsInput"
description: "a brand, and a place, a condition or a person; or one lead as its package"
section: concepts
address: /concepts/leadsinput
contract: 0476e35e6e275db5
---

# LeadsInput

a brand, and a place, a condition or a person; or one lead as its package

[figure: LeadsInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `brand` | `id` | yes |  |
| `place` | `text` | no |  |
| `condition` | [LeadCondition](/concepts/leadcondition) | no |  |
| `person` | `id` | no |  |
| `lead` | `id` | no | one lead, as its package |



## Routes that use it
- [`/v1/read/leads`](/reference/read/leads) takes it as input


---
title: "LeadsTo"
description: "one buyer profile leading to another: brought in, becoming, or crossing to, with the rate"
section: concepts
address: /concepts/leadsto
contract: 0476e35e6e275db5
---

# LeadsTo

one buyer profile leading to another: brought in, becoming, or crossing to, with the rate

[figure: LeadsTo is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `kind` | `id` | yes | the kind led to |
| `how` | `one of brings \| becomes \| crosses to` | yes |  |
| `rate` | [Summary](/concepts/summary) | no |  |



## Routes that use it
No route takes or returns LeadsTo directly. The record holds it, and the objects that point at it reach it.


---
title: "Leak"
description: "a resting place with no reader"
section: concepts
address: /concepts/leak
contract: 0476e35e6e275db5
---

# Leak

a resting place with no reader

[figure: Leak is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `what` | `text` | yes |  |
| `reader` | `text` | no |  |



## Routes that use it
No route takes or returns Leak directly. The record holds it, and the objects that point at it reach it.


---
title: "Lease"
description: "the acquisition system's leave to a host to call one way as one identity at one rate"
section: concepts
address: /concepts/lease
contract: 0476e35e6e275db5
---

# Lease

the acquisition system's leave to a host to call one way as one identity at one rate

[figure: Lease is a fact at shared scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | shared |
| key | the way, the identity, the host and when it ends |
| store | acquisition |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `way` | [AccessMethod](/concepts/accessmethod) | yes |  |
| `identity` | `id` | yes |  |
| `host` | `text` | yes |  |
| `rate` | [RateBound](/concepts/ratebound) | yes |  |
| `ends_at` | `time` | yes |  |
| `grant_number` | `count` | yes | a write with a stale grant number is rejected |



## Routes that use it
No route takes or returns Lease directly. The record holds it, and the objects that point at it reach it.


---
title: "Ledger"
description: "every move, action, forecast, effect and impact in order, with the budget spent by kind"
section: concepts
address: /concepts/ledger
contract: 0476e35e6e275db5
---

# Ledger

every move, action, forecast, effect and impact in order, with the budget spent by kind

[figure: Ledger is a view at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `entries` | [UnitRef](/concepts/unitref) | yes | in order |
| `spent` | [Cost](/concepts/cost) | yes |  |
| `budget` | [Budget](/concepts/budget) | yes |  |



## Routes that use it
- [`/v1/read/ledger`](/reference/read/ledger) returns it


---
title: "LedgerInput"
description: "a strategy and the window"
section: concepts
address: /concepts/ledgerinput
contract: 0476e35e6e275db5
---

# LedgerInput

a strategy and the window

[figure: LedgerInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `strategy` | `id` | yes |  |
| `window` | [Window](/concepts/window) | yes |  |



## Routes that use it
- [`/v1/read/ledger`](/reference/read/ledger) takes it as input


---
title: "LegalHold"
description: "a hold that stops an erasure of a subject, with its reason, who set it and until when"
section: concepts
address: /concepts/legalhold
contract: 0476e35e6e275db5
---

# LegalHold

a hold that stops an erasure of a subject, with its reason, who set it and until when

[figure: LegalHold is a definition at tenant scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | tenant |
| key | the subject |
| store | postgres |
| family | people |



## Fields


| field | type | required | note |
|---|---|---|---|
| `subject` | `id` | yes |  |
| `reason` | `text` | yes |  |
| `set_by` | `id` | yes |  |
| `until` | `date` | no |  |



## Routes that use it
No route takes or returns LegalHold directly. The record holds it, and the objects that point at it reach it.


---
title: "Level"
description: "a service level: a metric, an aggregation over a window, a target, and the beat it is computed on; the ops console reads levels, never raw metrics"
section: concepts
address: /concepts/level
contract: 0476e35e6e275db5
---

# Level

a service level: a metric, an aggregation over a window, a target, and the beat it is computed on; the ops console reads levels, never raw metrics

[figure: Level is a definition at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | platform |
| key | its name |
| store | postgres |
| family | observability |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `metric` | [Metric](/concepts/metric) | yes |  |
| `aggregation` | `one of p50 \| p95 \| p99 \| mean \| share \| count \| max` | yes |  |
| `window` | `duration` | yes |  |
| `target` | `share` | yes |  |
| `beat` | `duration` | yes |  |
| `alarm` | [Alarm](/concepts/alarm) | no | the alarm raised when the target is missed |



## Routes that use it
No route takes or returns Level directly. The record holds it, and the objects that point at it reach it.


---
title: "LevelReading"
description: "one computed value of one level"
section: concepts
address: /concepts/levelreading
contract: 0476e35e6e275db5
---

# LevelReading

one computed value of one level

[figure: LevelReading is a fact at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | platform |
| key | the level and the time |
| store | postgres+lake |
| family | observability |



## Fields


| field | type | required | note |
|---|---|---|---|
| `level` | [Level](/concepts/level) | yes |  |
| `at` | `time` | yes |  |
| `value` | `share` | yes |  |
| `met` | `bool` | yes |  |
| `population` | [PopulationStatement](/concepts/populationstatement) | yes | what the value was computed over |



## Routes that use it
No route takes or returns LevelReading directly. The record holds it, and the objects that point at it reach it.


---
title: "Lineage"
description: "every hop of a unit with its stamp and span, and its downstream footprint, marking unavailable what a store cannot answer"
section: concepts
address: /concepts/lineage
contract: 0476e35e6e275db5
---

# Lineage

every hop of a unit with its stamp and span, and its downstream footprint, marking unavailable what a store cannot answer

[figure: Lineage is a view at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `hops` | [HopStamp](/concepts/hopstamp) | yes |  |
| `footprint` | `[id]` | yes |  |
| `unavailable` | `[text]` | yes |  |



## Routes that use it
- [`/v1/read/lineage`](/reference/read/lineage) returns it


---
title: "LineageInput"
description: "an artefact or an acquisition unit"
section: concepts
address: /concepts/lineageinput
contract: 0476e35e6e275db5
---

# LineageInput

an artefact or an acquisition unit

[figure: LineageInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `artefact_hash` | `hash` | no |  |
| `unit` | `id` | no |  |



## Routes that use it
- [`/v1/read/lineage`](/reference/read/lineage) takes it as input


---
title: "Listener"
description: "one listening endpoint of one role: its port, protocol and exposure class"
section: concepts
address: /concepts/listener
contract: 0476e35e6e275db5
---

# Listener

one listening endpoint of one role: its port, protocol and exposure class

[figure: Listener is a definition at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | platform |
| key | the role and the port |
| store | postgres |
| family | network |



## Fields


| field | type | required | note |
|---|---|---|---|
| `role` | `one of api-gateway \| judge \| record \| work \| models \| local-server \| crawler \| identity-provider \| secrets-manager \| collector \| database \| durable-engine` | yes |  |
| `port` | `count` | yes |  |
| `protocol` | `one of https \| http \| websocket \| unix-socket \| named-pipe \| postgres \| grpc` | yes |  |
| `exposure` | `one of public-through-ingress \| private-network \| loopback-only` | yes | public means reachable only through the ingress; nothing binds a public interface itself |
| `health_path` | `text` | no | the path the load balancer and the ingress probe |
| `declared_in` | `text` | yes | the settings declaration that renders it; a listener found running and not declared fails the release check |



## Routes that use it
No route takes or returns Listener directly. The record holds it, and the objects that point at it reach it.


---
title: "ListMapping"
description: "how the items of a list field become entities of a kind, each keyed by the first of its key paths that holds a value, with one connection of a registered kind between the object's own entity and each item"
section: concepts
address: /concepts/listmapping
contract: 0476e35e6e275db5
---

# ListMapping

how the items of a list field become entities of a kind, each keyed by the first of its key paths that holds a value, with one connection of a registered kind between the object's own entity and each item

[figure: ListMapping is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `field` | `text` | yes | the list field of the source object |
| `kind` | [KindOfEntity](/concepts/kindofentity) | yes |  |
| `key_namespace` | `text` | yes |  |
| `key_paths` | `[text]` | yes | the first path that holds a value keys the item |
| `key_prefix` | `text` | no | put before the key's value, for a platform-and-handle key |
| `name_path` | `text` | no |  |
| `connection` | [KindOfConnection](/concepts/kindofconnection) | no |  |
| `own_role` | `text` | no | the object's entity's role |
| `item_role` | `text` | no | each item's role |
| `texts` | `[text]` | no | the item fields kept as long texts of the item's entity, each a claim stated by the source under the field's name, as the object's own texts are |
| `readings` | [KindOfMeasure](/concepts/kindofmeasure) | no | the item fields that are counts, each a reading of the measure on the item's entity at the time the page was read |
| `parent` | [ListParent](/concepts/listparent) | no | the thing each item belongs to, when the item carries its key |



## Routes that use it
No route takes or returns ListMapping directly. The record holds it, and the objects that point at it reach it.


---
title: "ListParent"
description: "the thing an item of a list belongs to (a comment's post, a reply's comment, an edition's newsletter): the item field that carries the parent's key, the parent's kind and key namespace, and the connection from the item to the parent with the role each takes"
section: concepts
address: /concepts/listparent
contract: 0476e35e6e275db5
---

# ListParent

the thing an item of a list belongs to (a comment's post, a reply's comment, an edition's newsletter): the item field that carries the parent's key, the parent's kind and key namespace, and the connection from the item to the parent with the role each takes

[figure: ListParent is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `key_path` | `text` | yes | the item field that carries the parent's key |
| `kind` | [KindOfEntity](/concepts/kindofentity) | yes |  |
| `key_namespace` | `text` | yes |  |
| `key_prefix` | `text` | no | put before the key's value |
| `connection` | [KindOfConnection](/concepts/kindofconnection) | yes |  |
| `item_role` | `text` | yes | the item's role in the connection |
| `parent_role` | `text` | yes | the parent's role |



## Routes that use it
No route takes or returns ListParent directly. The record holds it, and the objects that point at it reach it.


---
title: "LlmsIndex"
description: "the index a model reads: every page with a one-line description, and the addresses of the full twin, the API document, the manifest and the Context7 configuration"
section: concepts
address: /concepts/llmsindex
contract: 0476e35e6e275db5
---

# LlmsIndex

the index a model reads: every page with a one-line description, and the addresses of the full twin, the API document, the manifest and the Context7 configuration

[figure: LlmsIndex is a definition at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | platform |
| key | its address |
| store | postgres |
| family | documentation |



## Fields


| field | type | required | note |
|---|---|---|---|
| `address` | `text` | yes | /llms.txt |
| `full_twin` | `text` | yes | /llms-full.txt |
| `sections` | `[id]` | yes | the sections, by slug |
| `pages` | `count` | yes |  |
| `openapi` | `text` | yes | /openapi.json |
| `mcp_manifest` | `text` | yes | /mcp-manifest.json |
| `context7` | `text` | yes | context7.json at the repository's root |



## Routes that use it
No route takes or returns LlmsIndex directly. The record holds it, and the objects that point at it reach it.


---
title: "LoadBalancer"
description: "the rented load balancer in front of the ingress: ports, health check, and how the client address is passed"
section: concepts
address: /concepts/loadbalancer
contract: 0476e35e6e275db5
---

# LoadBalancer

the rented load balancer in front of the ingress: ports, health check, and how the client address is passed

[figure: LoadBalancer is a definition at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | platform |
| key | its address |
| store | postgres |
| family | network |



## Fields


| field | type | required | note |
|---|---|---|---|
| `address` | `address` | yes |  |
| `ports` | `[count]` | yes | 80 and 443 |
| `health_check` | `text` | yes | the path probed on every ingress copy |
| `client_address_header` | `text` | yes | the header the ingress trusts only from this balancer; a connection without it is rejected |
| `backends` | [MachineAddress](/concepts/machineaddress) | yes |  |



## Routes that use it
No route takes or returns LoadBalancer directly. The record holds it, and the objects that point at it reach it.


---
title: "LocalInput"
description: "a question in one of the ask tools' owning types, over the files the app may read"
section: concepts
address: /concepts/localinput
contract: 0476e35e6e275db5
---

# LocalInput

a question in one of the ask tools' owning types, over the files the app may read

[figure: LocalInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `tool` | `text` | yes | an ask tool |
| `input` | `json` | yes | the serialisation of that tool's input |



## Routes that use it
- [`/v1/ask/local`](/reference/ask/local) takes it as input


---
title: "LocalListener"
description: "one listener of the local server on a person's machine: the Unix domain socket or named pipe by default, and the TCP and WebSocket listeners when turned on, every one bound to the loopback address and never to a network interface; a caller proves itself with the install token in its first message"
section: concepts
address: /concepts/locallistener
contract: 0476e35e6e275db5
---

# LocalListener

one listener of the local server on a person's machine: the Unix domain socket or named pipe by default, and the TCP and WebSocket listeners when turned on, every one bound to the loopback address and never to a network interface; a caller proves itself with the install token in its first message

[figure: LocalListener is a definition at user scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | user |
| key | the app's install and the kind |
| store | postgres |
| family | network |



## Fields


| field | type | required | note |
|---|---|---|---|
| `kind` | `one of unix-socket \| named-pipe \| tcp \| websocket` | yes |  |
| `address` | `text` | yes | a path, or 127.0.0.1 with a port chosen at install |
| `enabled` | `bool` | yes | the socket always; TCP and WebSocket by a setting of the app |
| `install_token` | [VaultEntry](/concepts/vaultentry) | yes | kept in the operating system's keychain |
| `bound_to_loopback_only` | `bool` | yes | always true; a network interface fails the check |



## Routes that use it
No route takes or returns LocalListener directly. The record holds it, and the objects that point at it reach it.


---
title: "LocalProcedureInput"
description: "a procedure the app runs itself, with its steps in the app's own journal"
section: concepts
address: /concepts/localprocedureinput
contract: 0476e35e6e275db5
---

# LocalProcedureInput

a procedure the app runs itself, with its steps in the app's own journal

[figure: LocalProcedureInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `procedure` | [NamedProcedure](/concepts/namedprocedure) | yes |  |
| `inputs` | `json` | no |  |



## Routes that use it
- [`/v1/work/local_procedure`](/reference/work/local_procedure) takes it as input


---
title: "LogLine"
description: "one structured log line: time, role, run, level, a message in plain words, and the trace it belongs to; secret values are redacted before export"
section: concepts
address: /concepts/logline
contract: 0476e35e6e275db5
---

# LogLine

one structured log line: time, role, run, level, a message in plain words, and the trace it belongs to; secret values are redacted before export

[figure: LogLine is a fact at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | platform |
| key | its id |
| store | lake:landed |
| family | observability |



## Fields


| field | type | required | note |
|---|---|---|---|
| `at` | `time` | yes |  |
| `role` | `text` | yes |  |
| `run` | `id` | no |  |
| `level` | `one of debug \| info \| warn \| error` | yes |  |
| `message` | `text` | yes | plain words; never a code name a customer reads |
| `context` | [TelemetryContext](/concepts/telemetrycontext) | no |  |
| `fields` | `{text:text}` | no |  |



## Routes that use it
No route takes or returns LogLine directly. The record holds it, and the objects that point at it reach it.


---
title: "LookupAnswer"
description: "the entity, or the possible matches, or nothing"
section: concepts
address: /concepts/lookupanswer
contract: 0476e35e6e275db5
---

# LookupAnswer

the entity, or the possible matches, or nothing

[figure: LookupAnswer is a view at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `entity` | [Entity](/concepts/entity) | no |  |
| `possible` | [PossibleMatch](/concepts/possiblematch) | no |  |



## Routes that use it
- [`/v1/read/lookup`](/reference/read/lookup) returns it


---
title: "LookupInput"
description: "a key: a namespace with a value, or a name with a place"
section: concepts
address: /concepts/lookupinput
contract: 0476e35e6e275db5
---

# LookupInput

a key: a namespace with a value, or a name with a place

[figure: LookupInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `namespace` | `text` | no |  |
| `value` | `text` | no |  |
| `name` | `text` | no |  |
| `place` | `text` | no |  |
| `kind` | [KindOfEntity](/concepts/kindofentity) | no |  |
| `breadth` | `one of exact \| similar \| related \| broad` | no | with a name: the one candidate search of the record at that breadth, by exact keys, names and meaning, in place of the substring match |



## Routes that use it
- [`/v1/read/lookup`](/reference/read/lookup) takes it as input


---
title: "LoopGain"
description: "the gain a simulation read for one loop"
section: concepts
address: /concepts/loopgain
contract: 0476e35e6e275db5
---

# LoopGain

the gain a simulation read for one loop

[figure: LoopGain is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `loop` | `text` | yes |  |
| `gain` | [Interval](/concepts/interval) | yes |  |



## Routes that use it
No route takes or returns LoopGain directly. The record holds it, and the objects that point at it reach it.


---
title: "MachineAddress"
description: "one machine on the private network"
section: concepts
address: /concepts/machineaddress
contract: 0476e35e6e275db5
---

# MachineAddress

one machine on the private network

[figure: MachineAddress is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | network |



## Fields


| field | type | required | note |
|---|---|---|---|
| `machine` | `text` | yes |  |
| `address` | `address` | yes |  |
| `in_control_plane` | `bool` | yes |  |



## Routes that use it
No route takes or returns MachineAddress directly. The record holds it, and the objects that point at it reach it.


---
title: "MakeBrandDesignSystemInput"
description: "the brand whose design system is made from the pages held on its site"
section: concepts
address: /concepts/makebranddesignsysteminput
contract: 0476e35e6e275db5
---

# MakeBrandDesignSystemInput

the brand whose design system is made from the pages held on its site

[figure: MakeBrandDesignSystemInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `brand` | `id` | yes |  |
| `website` | `address` | no | defaults to the brand row's own |



## Routes that use it
- [`/v1/act/make_brand_design_system`](/reference/act/make_brand_design_system) takes it as input


---
title: "MakeMarketTwinInput"
description: "the market and the template to instance a twin from"
section: concepts
address: /concepts/makemarkettwininput
contract: 0476e35e6e275db5
---

# MakeMarketTwinInput

the market and the template to instance a twin from

[figure: MakeMarketTwinInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `vertical` | `id` | yes |  |
| `segment` | `id` | no |  |
| `brand` | `id` | yes |  |
| `template` | [SystemsModelTemplate](/concepts/systemsmodeltemplate) | yes |  |
| `way` | [WayOfGoingToMarket](/concepts/wayofgoingtomarket) | no |  |
| `as_of` | `time` | no | today when absent |



## Routes that use it
- [`/v1/act/make_market_twin`](/reference/act/make_market_twin) takes it as input


---
title: "Map"
description: "the brand's graph, every rival in the same shape, the markets, the channels, the chain, the voices, and for each part its coverage; it holds no rows of its own"
section: concepts
address: /concepts/map
contract: 0476e35e6e275db5
---

# Map

the brand's graph, every rival in the same shape, the markets, the channels, the chain, the voices, and for each part its coverage; it holds no rows of its own

[figure: Map is a view at brand scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | brand |
| key | the brand and the two dates |
| store | derived |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `brand` | `id` | yes |  |
| `as_of` | [TwoDates](/concepts/twodates) | yes |  |
| `parts` | [MapPart](/concepts/mappart) | yes |  |
| `rivals` | `[id]` | yes |  |
| `under_test` | `[id]` | yes |  |



## Routes that use it
- [`/v1/read/map`](/reference/read/map) returns it
- [`/v1/act/map_brand`](/reference/act/map_brand) returns it


---
title: "MapBrandInput"
description: "a web address, and the tenant it is mapped for"
section: concepts
address: /concepts/mapbrandinput
contract: 0476e35e6e275db5
---

# MapBrandInput

a web address, and the tenant it is mapped for

[figure: MapBrandInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `website` | `address` | yes |  |
| `name` | `text` | no |  |
| `tenant` | `id` | yes |  |



## Routes that use it
- [`/v1/act/map_brand`](/reference/act/map_brand) takes it as input


---
title: "MapInput"
description: "a brand, and the two dates"
section: concepts
address: /concepts/mapinput
contract: 0476e35e6e275db5
---

# MapInput

a brand, and the two dates

[figure: MapInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `brand` | `id` | yes |  |



## Routes that use it
- [`/v1/read/chain`](/reference/read/chain) takes it as input
- [`/v1/read/map`](/reference/read/map) takes it as input


---
title: "MapPart"
description: "one part of the map: measured, under test or never read, and never two"
section: concepts
address: /concepts/mappart
contract: 0476e35e6e275db5
---

# MapPart

one part of the map: measured, under test or never read, and never two

[figure: MapPart is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `units` | `[id]` | yes |  |
| `position` | `one of measured \| under test \| never read` | yes |  |
| `coverage` | [CoverageReading](/concepts/coveragereading) | yes |  |
| `not_ready` | `[id]` | yes | the units of this part that are visibly not ready, a subset of units; a part whose units carry no readiness lists none |



## Routes that use it
No route takes or returns MapPart directly. The record holds it, and the objects that point at it reach it.


---
title: "Mapping"
description: "how a source object becomes a registered kind: an entity, a content item, a fact (a reading, a claim, a connection, a vector, a control result) or a definition; with its connections, identifiers, the two times and readings"
section: concepts
address: /concepts/mapping
contract: 0476e35e6e275db5
---

# Mapping

how a source object becomes a registered kind: an entity, a content item, a fact (a reading, a claim, a connection, a vector, a control result) or a definition; with its connections, identifiers, the two times and readings

[figure: Mapping is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | the source object |
| store | postgres |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `source_object` | [SourceObject](/concepts/sourceobject) | yes |  |
| `becomes` | [Kind](/concepts/kind) | yes |  |
| `connections` | [MappingConnection](/concepts/mappingconnection) | yes |  |
| `identifiers` | [MappingIdentifier](/concepts/mappingidentifier) | yes |  |
| `header_prefix` | `text` | no | put before every identity value of the shared header (the author's account, the community, the parent, the thread's root): the platform's own prefix, so a header id compares with the own ids the identifiers' prefixes write |
| `times` | `{text:text}` | yes | which fill the two times |
| `readings` | [KindOfMeasure](/concepts/kindofmeasure) | yes |  |
| `required_fields` | `[text]` | yes |  |
| `self_asserted` | `[text]` | yes |  |
| `texts` | `[text]` | no | the fields kept as long texts of the entity the row becomes: each written as a claim stated by the source under the field's name, and given meaning under the model, so a bio, a description or a readme is searchable by meaning and grounds a later capture |
| `kinds` | `{text:text}` | no | the source's own kind words, each to a registered kind of entity, when the object carries a kind field |
| `kind` | [KindOfEntity](/concepts/kindofentity) | no | the kind of entity every row of the object becomes, for an object whose rows carry no kind field (a table of accounts, of communities, of domains); kinds and kind are never both set |
| `lists` | [ListMapping](/concepts/listmapping) | no | list fields whose items become entities of their own |



## Routes that use it
No route takes or returns Mapping directly. The record holds it, and the objects that point at it reach it.


---
title: "MappingConnection"
description: "a link that becomes a connection"
section: concepts
address: /concepts/mappingconnection
contract: 0476e35e6e275db5
---

# MappingConnection

a link that becomes a connection

[figure: MappingConnection is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `link` | `text` | yes |  |
| `kind` | [KindOfConnection](/concepts/kindofconnection) | yes |  |
| `role` | `text` | yes |  |
| `field` | `text` | no | the declared field of the object that fills the role, when the object's own fields state the connection (a table of who is active where, of who links to which host) rather than the shared header; the field's identity, its namespace and prefix, is the mapping's identifier for that field |



## Routes that use it
No route takes or returns MappingConnection directly. The record holds it, and the objects that point at it reach it.


---
title: "MappingIdentifier"
description: "an id that becomes an identifier"
section: concepts
address: /concepts/mappingidentifier
contract: 0476e35e6e275db5
---

# MappingIdentifier

an id that becomes an identifier

[figure: MappingIdentifier is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `id` | `text` | yes |  |
| `namespace` | `text` | yes |  |
| `trust_rank` | `count` | yes |  |
| `prefix` | `text` | no | put before the value, for a platform-and-handle key |
| `prefix_by_kind` | `{text:text}` | no | for an object whose kind field decides the prefix (a table of comments and submissions together), the prefix for each kind word; the row's kind word chooses it, and a word absent here leaves the row without an own id |



## Routes that use it
No route takes or returns MappingIdentifier directly. The record holds it, and the objects that point at it reach it.


---
title: "MarginCheck"
description: "the ladder's gross margin against the metered cost of a lead and of a call, in one of three positions; never a typed cost"
section: concepts
address: /concepts/margincheck
contract: 0476e35e6e275db5
---

# MarginCheck

the ladder's gross margin against the metered cost of a lead and of a call, in one of three positions; never a typed cost

[figure: MarginCheck is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | the margin check of a study |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `position` | `one of measured \| never measured \| withheld` | yes |  |
| `cost_per_lead` | `money` | no | from metering |
| `cost_per_call` | `money` | no | from metering |
| `floor` | `share` | yes | the parameter |
| `cleared` | `bool` | no |  |
| `reason` | `text` | no |  |



## Routes that use it
No route takes or returns MarginCheck directly. The record holds it, and the objects that point at it reach it.


---
title: "Market"
description: "a buyer profile in a place, sized in three positions, with the four stages"
section: concepts
address: /concepts/market
contract: 0476e35e6e275db5
---

# Market

a buyer profile in a place, sized in three positions, with the four stages

[figure: Market is a definition at brand scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | brand |
| key | a buyer profile in a place |
| store | postgres |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `kind_of_buyer` | `id` | yes |  |
| `place` | `id` | yes |  |
| `stages` | [MarketStage](/concepts/marketstage) | yes |  |
| `size` | [NumberInPosition](/concepts/numberinposition) | yes | measured, estimated or stipulated |
| `silent_remainder` | `share` | no |  |
| `gaps` | [CoverageGap](/concepts/coveragegap) | yes |  |
| `sizing` | [MarketSizing](/concepts/marketsizing) | no | the four sizing positions, each with its definition |



## Routes that use it
- [`/v1/read/market`](/reference/read/market) returns it


---
title: "MarketEvent"
description: "something that happened to an entity in the market"
section: concepts
address: /concepts/marketevent
contract: 0476e35e6e275db5
---

# MarketEvent

something that happened to an entity in the market

[figure: MarketEvent is a fact at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | follows |
| key | the entity, the kind of event and the source's own id |
| store | lake:ready |
| family | record |



## Fields


| field | type | required | note |
|---|---|---|---|
| `entity` | `id` | yes |  |
| `kind` | [KindOfMarketEvent](/concepts/kindofmarketevent) | yes |  |
| `adds` | `json` | no |  |



## Routes that use it
No route takes or returns MarketEvent directly. The record holds it, and the objects that point at it reach it.


---
title: "MarketInput"
description: "a brand, a segment, the window"
section: concepts
address: /concepts/marketinput
contract: 0476e35e6e275db5
---

# MarketInput

a brand, a segment, the window

[figure: MarketInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `brand` | `id` | yes |  |
| `segment` | `id` | yes |  |
| `window` | [Window](/concepts/window) | yes |  |



## Routes that use it
- [`/v1/read/market`](/reference/read/market) takes it as input


---
title: "MarketParticipant"
description: "one party of a market in one role on one stock of a vertical's chain, with its buying behaviour and its impact on the other roles; placed by a person, by the placement method of the library, or by a template"
section: concepts
address: /concepts/marketparticipant
contract: 0476e35e6e275db5
---

# MarketParticipant

one party of a market in one role on one stock of a vertical's chain, with its buying behaviour and its impact on the other roles; placed by a person, by the placement method of the library, or by a template

[figure: MarketParticipant is a definition at brand scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | brand |
| key | the party, the role and the vertical, versioned |
| store | postgres |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `vertical` | `id` | yes |  |
| `segment` | `id` | no |  |
| `stock` | `text` | yes | the chain stock it sits on, by name |
| `party` | `id` | yes | an entity the record holds |
| `party_kind` | `one of company \| brand \| person \| account \| community \| organisation` | yes |  |
| `role` | [RoleAroundADecision](/concepts/rolearoundadecision) | yes |  |
| `side` | `one of demand \| supply \| intermediary \| influence \| rules` | yes |  |
| `behaviour` | [BuyingBehaviour](/concepts/buyingbehaviour) | no | absent until read |
| `impact_on` | [ParticipantImpact](/concepts/participantimpact) | yes |  |
| `placed_by` | `one of a person \| the placement method \| a template` | yes |  |
| `evidence` | [EvidenceRef](/concepts/evidenceref) | yes |  |
| `version` | `count` | yes |  |
| `content_hash` | `hash` | yes |  |
| `state` | [Readiness](/concepts/readiness) | yes | not ready without evidence or with a role the vertical does not name |



## Routes that use it
- [`/v1/act/place_participant`](/reference/act/place_participant) returns it


---
title: "MarketSimulation"
description: "one run of a systems model template over the record's readings with a strategy laid over it as interventions; the one evaluator steps every flow; deterministic under its seed; stops at its budget with the trajectories it reached"
section: concepts
address: /concepts/marketsimulation
contract: 0476e35e6e275db5
---

# MarketSimulation

one run of a systems model template over the record's readings with a strategy laid over it as interventions; the one evaluator steps every flow; deterministic under its seed; stops at its budget with the trajectories it reached

[figure: MarketSimulation is a work at brand scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | work |
| scope | brand |
| key | the template version, the vertical, the readings hash, the interventions hash and the seed |
| store | postgres |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `template` | [SystemsModelTemplate](/concepts/systemsmodeltemplate) | yes |  |
| `template_version` | `count` | yes |  |
| `vertical` | `id` | yes |  |
| `segment` | `id` | no |  |
| `brand` | `id` | no | absent for a simulation of the shared market |
| `readings_hash` | `hash` | yes | the hash of every chain count, benchmark and stated number the run read, at their versions |
| `interventions` | [Intervention](/concepts/intervention) | yes |  |
| `horizon` | `duration` | yes |  |
| `step` | `duration` | yes |  |
| `samples` | `count` | yes |  |
| `seed` | `count` | yes |  |
| `frame` | `id` | no | the frame it wrote |
| `why_failed` | `text` | no |  |
| `elapsed` | `duration` | no |  |



## Routes that use it
- [`/v1/work/lay_strategy`](/reference/work/lay_strategy) returns it
- [`/v1/work/simulate_market`](/reference/work/simulate_market) returns it


---
title: "MarketSimulationFrame"
description: "what a market simulation gave: the trajectory of every stock, the gain of every loop, the sensitivity to every intervention, and the set of options that compares the strategies laid over the same template"
section: concepts
address: /concepts/marketsimulationframe
contract: 0476e35e6e275db5
---

# MarketSimulationFrame

what a market simulation gave: the trajectory of every stock, the gain of every loop, the sensitivity to every intervention, and the set of options that compares the strategies laid over the same template

[figure: MarketSimulationFrame is a fact at brand scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | brand |
| key | the simulation |
| store | postgres+lake |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `simulation` | `id` | yes |  |
| `trajectories` | [StockTrajectory](/concepts/stocktrajectory) | yes |  |
| `loop_gains` | [LoopGain](/concepts/loopgain) | yes |  |
| `sensitivity` | [Sensitivity](/concepts/sensitivity) | yes | the change in each output for a one-step change of each intervention |
| `participants_read` | `[id]` | yes | the participants whose behaviour the run read |
| `level` | `share` | yes | the level of every interval |
| `options` | `id` | no | the set of options document that compares strategies over this template |



## Routes that use it
- [`/v1/read/simulation_frame`](/reference/read/simulation_frame) returns it


---
title: "MarketSimulationInput"
description: "the template, the market, the interventions that stand for a strategy, and the run's bounds"
section: concepts
address: /concepts/marketsimulationinput
contract: 0476e35e6e275db5
---

# MarketSimulationInput

the template, the market, the interventions that stand for a strategy, and the run's bounds

[figure: MarketSimulationInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `template` | [SystemsModelTemplate](/concepts/systemsmodeltemplate) | yes |  |
| `vertical` | `id` | yes |  |
| `segment` | `id` | no |  |
| `brand` | `id` | no |  |
| `interventions` | [Intervention](/concepts/intervention) | yes |  |
| `horizon` | `duration` | no | the template's when absent |
| `samples` | `count` | no | the parameter's when absent |
| `seed` | `count` | no |  |



## Routes that use it
- [`/v1/work/simulate_market`](/reference/work/simulate_market) takes it as input


---
title: "MarketSizing"
description: "one sizing position of a market, with the count and the definition the reading used"
section: concepts
address: /concepts/marketsizing
contract: 0476e35e6e275db5
---

# MarketSizing

one sizing position of a market, with the count and the definition the reading used

[figure: MarketSizing is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `position` | [SizingPosition](/concepts/sizingposition) | yes |  |
| `count` | [NumberInPosition](/concepts/numberinposition) | yes | measured, estimated or stipulated |
| `definition` | `text` | yes | what the position counts, in the engagement's own words |



## Routes that use it
No route takes or returns MarketSizing directly. The record holds it, and the objects that point at it reach it.


---
title: "MarketStage"
description: "one of the four stages of a market"
section: concepts
address: /concepts/marketstage
contract: 0476e35e6e275db5
---

# MarketStage

one of the four stages of a market

[figure: MarketStage is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `one of aware \| evaluating \| trialling \| buying` | yes |  |
| `count` | [Summary](/concepts/summary) | yes |  |
| `value` | [Summary](/concepts/summary) | no |  |
| `note` | `text` | no |  |
| `mode` | `one of present \| to be cultivated \| unknown` | no | read from the counts against the bar of the intend family, never set |



## Routes that use it
No route takes or returns MarketStage directly. The record holds it, and the objects that point at it reach it.


---
title: "MarketTwin"
description: "A digital twin is a model of a market that stays current because the record feeds it."
section: concepts
address: /concepts/markettwin
contract: 0476e35e6e275db5
---

# MarketTwin

A digital twin is a model of a market that stays current because the record feeds it.

[figure: MarketTwin is a definition at brand scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | brand |
| key | the vertical, the template version, the brand and the readings hash, versioned |
| store | postgres |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `vertical` | `id` | yes |  |
| `segment` | `id` | no |  |
| `brand` | `id` | yes |  |
| `template` | [SystemsModelTemplate](/concepts/systemsmodeltemplate) | yes |  |
| `template_version` | `count` | yes |  |
| `family` | [ModelFamily](/concepts/modelfamily) | yes |  |
| `way` | [WayOfGoingToMarket](/concepts/wayofgoingtomarket) | no | the way of going to market the twin serves |
| `chain` | `id` | yes | the vertical's chain the stocks start from |
| `participants` | `[id]` | yes | the participants placed on the chain for this brand |
| `readings_hash` | `hash` | yes | the hash of every reading the twin was instanced over, at their versions |
| `as_of` | `time` | yes | the date the state is read as of |
| `state` | [StockLevel](/concepts/stocklevel) | yes | the level of every stock as of the date |
| `steps` | `[id]` | yes | the simulations run on this twin, in order |
| `strategy` | `id` | no | the strategy whose plays are the twin's interventions |
| `game` | [GameOfRoles](/concepts/gameofroles) | no | the game of roles laid over the twin, where its family or its template carries one |
| `version` | `count` | yes |  |
| `content_hash` | `hash` | yes |  |
| `state_of` | [Readiness](/concepts/readiness) | yes | ready when every stock the template needs has a reading or is marked never measured, and the template is ready |



## Routes that use it
- [`/v1/read/market_twin`](/reference/read/market_twin) returns it
- [`/v1/act/make_market_twin`](/reference/act/make_market_twin) returns it


---
title: "MarketTwinInput"
description: "the twin to read, as of a date"
section: concepts
address: /concepts/markettwininput
contract: 0476e35e6e275db5
---

# MarketTwinInput

the twin to read, as of a date

[figure: MarketTwinInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `twin` | `id` | yes |  |
| `as_of` | `time` | no |  |



## Routes that use it
- [`/v1/read/market_twin`](/reference/read/market_twin) takes it as input


---
title: "MarketTwinState"
description: "the state of a twin at one step of one simulation: the level of every stock, so the twin's trajectory is facts in gold and never a rebuild"
section: concepts
address: /concepts/markettwinstate
contract: 0476e35e6e275db5
---

# MarketTwinState

the state of a twin at one step of one simulation: the level of every stock, so the twin's trajectory is facts in gold and never a rebuild

[figure: MarketTwinState is a fact at brand scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | brand |
| key | the twin, the step and the time |
| store | postgres+lake |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `twin` | `id` | yes |  |
| `simulation` | `id` | yes |  |
| `step` | `count` | yes |  |
| `at` | `time` | yes |  |
| `levels` | [StockLevel](/concepts/stocklevel) | yes |  |



## Routes that use it
No route takes or returns MarketTwinState directly. The record holds it, and the objects that point at it reach it.


---
title: "MarkLeadInput"
description: "the lead, the condition, and a reason where the condition asks for one"
section: concepts
address: /concepts/markleadinput
contract: 0476e35e6e275db5
---

# MarkLeadInput

the lead, the condition, and a reason where the condition asks for one

[figure: MarkLeadInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `lead` | `id` | yes |  |
| `condition` | [LeadCondition](/concepts/leadcondition) | yes |  |
| `reason` | `text` | no |  |



## Routes that use it
- [`/v1/act/mark_lead`](/reference/act/mark_lead) takes it as input


---
title: "MarkRivalInput"
description: "a brand and the rival, with the evidence"
section: concepts
address: /concepts/markrivalinput
contract: 0476e35e6e275db5
---

# MarkRivalInput

a brand and the rival, with the evidence

[figure: MarkRivalInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `brand` | `id` | yes |  |
| `rival` | `id` | yes |  |
| `evidence` | [EvidenceRef](/concepts/evidenceref) | yes |  |



## Routes that use it
- [`/v1/act/mark_rival`](/reference/act/mark_rival) takes it as input


---
title: "Measure"
description: "a measure, as a registered kind with a value"
section: concepts
address: /concepts/measure
contract: 0476e35e6e275db5
---

# Measure

a measure, as a registered kind with a value

[figure: Measure is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | registers |



## Fields


| field | type | required | note |
|---|---|---|---|
| `kind` | [KindOfMeasure](/concepts/kindofmeasure) | yes |  |
| `value` | `json` | yes |  |
| `dimension` | `text` | yes |  |
| `read_at` | [TimeWithBasis](/concepts/timewithbasis) | yes |  |



## Routes that use it
No route takes or returns Measure directly. The record holds it, and the objects that point at it reach it.


---
title: "MeasurementOfBars"
description: "one measurement of the bars of nearness under a model: the probes in use, the units read, the shares each breadth admits, and the bars written"
section: concepts
address: /concepts/measurementofbars
contract: 0476e35e6e275db5
---

# MeasurementOfBars

one measurement of the bars of nearness under a model: the probes in use, the units read, the shares each breadth admits, and the bars written

[figure: MeasurementOfBars is a work at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | work |
| scope | platform |
| key | the model and the day |
| store | postgres |
| family | rules_engine |



## Fields


| field | type | required | note |
|---|---|---|---|
| `model` | [Model](/concepts/model) | yes |  |
| `probes` | `count` | yes | the distinct concepts of the kept predicates' semantic leaves |
| `units` | `count` | yes | the units with a vector under the model |
| `shares` | `{text:share}` | yes | the share of the population each breadth admits, from the parameter row |
| `bars` | [BarsOfNearness](/concepts/barsofnearness) | no | absent while the measurement is not possible, with the reason |
| `version_written` | `count` | no | the version of the parameter row written |
| `why_stopped` | `text` | no |  |



## Routes that use it
No route takes or returns MeasurementOfBars directly. The record holds it, and the objects that point at it reach it.


---
title: "Membership"
description: "a user in a tenant, as a member or a guest"
section: concepts
address: /concepts/membership
contract: 0476e35e6e275db5
---

# Membership

a user in a tenant, as a member or a guest

[figure: Membership is a definition at tenant scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | tenant |
| key | the user and the tenant |
| store | postgres |
| family | people |



## Fields


| field | type | required | note |
|---|---|---|---|
| `user` | `id` | yes |  |
| `tenant` | `id` | yes |  |
| `kind` | `one of member \| guest` | yes | a guest's home tenant is another one |
| `state` | [Readiness](/concepts/readiness) | yes |  |



## Routes that use it
- [`/v1/act/membership`](/reference/act/membership) returns it


---
title: "MembershipInput"
description: "invite, suspend or remove a user, as a member or a guest"
section: concepts
address: /concepts/membershipinput
contract: 0476e35e6e275db5
---

# MembershipInput

invite, suspend or remove a user, as a member or a guest

[figure: MembershipInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `user` | `id` | no |  |
| `mail` | `address` | no | to invite |
| `tenant` | `id` | yes |  |
| `do` | `one of invite \| suspend \| remove` | yes |  |
| `kind` | `one of member \| guest` | no |  |



## Routes that use it
- [`/v1/act/membership`](/reference/act/membership) takes it as input


---
title: "Memory"
description: "a decision, a preference, a correction or a standing instruction, at strategy or user scope; never a permission"
section: concepts
address: /concepts/memory
contract: 0476e35e6e275db5
---

# Memory

a decision, a preference, a correction or a standing instruction, at strategy or user scope; never a permission

[figure: Memory is a fact at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | follows |
| key | its scope and the moment |
| store | postgres |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `kind` | `one of a decision \| a preference \| a correction \| a standing instruction` | yes |  |
| `text` | `text` | yes |  |
| `scope` | [Scope](/concepts/scope) | yes |  |
| `ended_by` | `id` | no | a later fact that ends it |



## Routes that use it
- [`/v1/act/remember`](/reference/act/remember) returns it


---
title: "Mention"
description: "a thing named in an observation, on its way to an entity"
section: concepts
address: /concepts/mention
contract: 0476e35e6e275db5
---

# Mention

a thing named in an observation, on its way to an entity

[figure: Mention is a work at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | work |
| scope | follows |
| key | the observation and where in it the thing is named |
| store | postgres |
| family | identity |



## Fields


| field | type | required | note |
|---|---|---|---|
| `observation` | `id` | yes |  |
| `where` | `text` | yes |  |
| `kind` | [KindOfEntity](/concepts/kindofentity) | yes | the kind the map gave it |
| `identifiers` | [Identifier](/concepts/identifier) | yes | once keyed |
| `set_aside_reason` | `text` | no |  |



## Routes that use it
No route takes or returns Mention directly. The record holds it, and the objects that point at it reach it.


---
title: "MentionKind"
description: "what kind of thing a page's property names, so the grounding knows a page's author is an account and its employer a company: one row per property, for every platform or the ones listed; a template's field whose type names a kind of entity overrides it, and the person's settled words on each property and platform…"
section: concepts
address: /concepts/mentionkind
contract: 0476e35e6e275db5
---

# MentionKind

what kind of thing a page's property names, so the grounding knows a page's author is an account and its employer a company: one row per property, for every platform or the ones listed; a template's field whose type names a kind of entity overrides it, and the person's settled words on each property and platform…

[figure: MentionKind is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | the property and the platforms |
| store | postgres |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `property` | `text` | yes | the property's name as the templates write it |
| `kind` | [KindOfEntity](/concepts/kindofentity) | yes |  |
| `platforms` | `[text]` | yes | empty for every platform |
| `note` | `text` | no |  |



## Routes that use it
No route takes or returns MentionKind directly. The record holds it, and the objects that point at it reach it.


---
title: "Merge"
description: "one fact recording that two entities are one; it changes no other fact"
section: concepts
address: /concepts/merge
contract: 0476e35e6e275db5
---

# Merge

one fact recording that two entities are one; it changes no other fact

[figure: Merge is a fact at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | follows |
| key | the decision that caused it |
| store | postgres+lake |
| family | identity |



## Fields


| field | type | required | note |
|---|---|---|---|
| `decision` | `id` | yes |  |
| `first` | `id` | yes |  |
| `second` | `id` | yes |  |
| `answers_for_both` | `id` | yes |  |
| `claim_precedence` | `text` | yes | which of two claims shows first |
| `parted_by` | `id` | no |  |



## Routes that use it
No route takes or returns Merge directly. The record holds it, and the objects that point at it reach it.


---
title: "MeteredUsage"
description: "one row per metered call, written by the metering middleware in the same unit of work as the call; a call whose row cannot be written does not complete"
section: concepts
address: /concepts/meteredusage
contract: 0476e35e6e275db5
---

# MeteredUsage

one row per metered call, written by the metering middleware in the same unit of work as the call; a call whose row cannot be written does not complete

[figure: MeteredUsage is a fact at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | follows |
| key | the call's key and the kind |
| store | postgres+lake |
| family | operations |



## Fields


| field | type | required | note |
|---|---|---|---|
| `kind` | [KindOfUsage](/concepts/kindofusage) | yes |  |
| `quantity` | `count` | yes | in the kind's unit |
| `cost` | [Cost](/concepts/cost) | yes | with its basis |
| `caller` | [Caller](/concepts/caller) | yes | read from the telemetry context, never from an argument |
| `scope` | [Scope](/concepts/scope) | yes | the tenant, brand or strategy |
| `grant` | `id` | no |  |
| `work_key` | `text` | yes | the job's, the move's or the turn's key |
| `trace_id` | `text` | yes |  |
| `provider` | `text` | no |  |
| `at` | `time` | yes |  |



## Routes that use it
No route takes or returns MeteredUsage directly. The record holds it, and the objects that point at it reach it.


---
title: "Method"
description: "one research method of the library: the question it settles, when it applies and when not, its inputs, the deciding number and its bar, the control, its steps, its validity threats with the answer to each, and what it leaves on the record"
section: concepts
address: /concepts/method
contract: 0476e35e6e275db5
---

# Method

one research method of the library: the question it settles, when it applies and when not, its inputs, the deciding number and its bar, the control, its steps, its validity threats with the answer to each, and what it leaves on the record

[figure: Method is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | its name and version |
| store | postgres |
| family | models |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes | the field's name for the method |
| `question` | `text` | yes |  |
| `applies_when` | `text` | yes |  |
| `not_when` | `text` | yes |  |
| `inputs` | `[text]` | yes | owning types |
| `deciding_number` | `text` | yes | and its bar |
| `control` | `text` | yes |  |
| `steps` | `[text]` | yes | each a step of the named procedure |
| `threats` | `[json]` | yes | threat, answer |
| `leaves` | `[text]` | yes | with the basis of each |
| `state` | [Readiness](/concepts/readiness) | yes | not ready without a deciding number, a control or an answered threat |
| `version` | `count` | yes |  |



## Routes that use it
No route takes or returns Method directly. The record holds it, and the objects that point at it reach it.


---
title: "MethodsInput"
description: "a question to find methods for, or nothing for every method"
section: concepts
address: /concepts/methodsinput
contract: 0476e35e6e275db5
---

# MethodsInput

a question to find methods for, or nothing for every method

[figure: MethodsInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `question` | `text` | no |  |



## Routes that use it
- [`/v1/read/methods`](/reference/read/methods) takes it as input


---
title: "Metric"
description: "one named measurement with its kind, its unit and the labels it may carry"
section: concepts
address: /concepts/metric
contract: 0476e35e6e275db5
---

# Metric

one named measurement with its kind, its unit and the labels it may carry

[figure: Metric is a definition at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | platform |
| key | its name |
| store | postgres |
| family | observability |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `kind` | `one of counter \| gauge \| histogram` | yes |  |
| `unit` | `text` | yes | seconds, bytes, requests, dollars; a metric without a unit fails the check |
| `labels` | `[text]` | yes | from the label allow-list; never a free value |
| `what_it_measures` | `text` | yes |  |



## Routes that use it
No route takes or returns Metric directly. The record holds it, and the objects that point at it reach it.


---
title: "MetricReading"
description: "one point of one metric"
section: concepts
address: /concepts/metricreading
contract: 0476e35e6e275db5
---

# MetricReading

one point of one metric

[figure: MetricReading is a fact at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | platform |
| key | the metric, the labels and the time |
| store | lake:landed |
| family | observability |



## Fields


| field | type | required | note |
|---|---|---|---|
| `metric` | [Metric](/concepts/metric) | yes |  |
| `labels` | `{text:text}` | yes |  |
| `at` | `time` | yes |  |
| `value` | `share` | yes |  |
| `bucket` | `text` | no | for a histogram |



## Routes that use it
No route takes or returns MetricReading directly. The record holds it, and the objects that point at it reach it.


---
title: "Migration"
description: "a change to a schema, forward only, re-declaring the list of applied migrations"
section: concepts
address: /concepts/migration
contract: 0476e35e6e275db5
---

# Migration

a change to a schema, forward only, re-declaring the list of applied migrations

[figure: Migration is a definition at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | platform |
| key | its number |
| store | postgres |
| family | releases |



## Fields


| field | type | required | note |
|---|---|---|---|
| `number` | `count` | yes |  |
| `applies_to` | `text` | yes |  |
| `declared_list` | `[count]` | yes |  |
| `allows_rollback` | `bool` | yes |  |



## Routes that use it
No route takes or returns Migration directly. The record holds it, and the objects that point at it reach it.


---
title: "Model"
description: "a model: the task it decides, its kind, its address, its calibration, its state"
section: concepts
address: /concepts/model
contract: 0476e35e6e275db5
---

# Model

a model: the task it decides, its kind, its address, its calibration, its state

[figure: Model is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | its name and version |
| store | postgres |
| family | models |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `version` | `text` | yes |  |
| `task` | `text` | yes | in one sentence |
| `kind` | `one of classifier \| embedder \| estimator \| generator \| normaliser \| chunker \| language head \| quality head \| near-duplicate method \| pooling recipe \| probe` | yes |  |
| `width` | `count` | no | for an embedder |
| `address` | `address` | yes | with no default |
| `provider` | `text` | yes | who serves it; the settings name the provider's key by its environment name |
| `leaves_the_platform` | `bool` | yes | whether text sent to it leaves the platform |
| `price_per_million_prompt_tokens` | `money` | no | the list price the provider states |
| `price_per_million_completion_tokens` | `money` | no | the list price the provider states; none for an embedder |
| `longest_input` | `count` | no | tokens |
| `prefix` | `text` | no | the prefix the model expects before a query, if any |
| `licence` | `text` | no |  |
| `known_examples` | `[id]` | yes |  |
| `controls` | [ControlResult](/concepts/controlresult) | yes |  |
| `statistics` | [ModelStatistics](/concepts/modelstatistics) | no |  |
| `cost_per_call` | [Cost](/concepts/cost) | no |  |
| `state` | [Readiness](/concepts/readiness) | yes |  |
| `life` | `one of candidate \| under test \| in shadow \| frozen \| serving \| retired` | yes |  |



## Routes that use it
No route takes or returns Model directly. The record holds it, and the objects that point at it reach it.


---
title: "ModelCall"
description: "one call of a model, metered against the unit it served"
section: concepts
address: /concepts/modelcall
contract: 0476e35e6e275db5
---

# ModelCall

one call of a model, metered against the unit it served

[figure: ModelCall is a fact at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | follows |
| key | the model, the unit and the moment |
| store | postgres+lake |
| family | models |



## Fields


| field | type | required | note |
|---|---|---|---|
| `model` | [Model](/concepts/model) | yes |  |
| `unit` | `id` | yes |  |
| `tokens` | `count` | no |  |
| `size` | `bytes` | no |  |
| `cost` | [Cost](/concepts/cost) | yes |  |
| `outcome` | `one of answered \| refused \| failed` | yes |  |
| `run` | `id` | yes |  |



## Routes that use it
No route takes or returns ModelCall directly. The record holds it, and the objects that point at it reach it.


---
title: "ModelFamiliesInput"
description: "the vertical or the representation the families must fit; both absent asks for every family"
section: concepts
address: /concepts/modelfamiliesinput
contract: 0476e35e6e275db5
---

# ModelFamiliesInput

the vertical or the representation the families must fit; both absent asks for every family

[figure: ModelFamiliesInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `vertical` | `id` | no |  |
| `representation` | `one of stocks and flows \| a graph of participants and handovers \| a hypergraph of co-presence \| agents with behaviours \| a game of roles` | no |  |



## Routes that use it
- [`/v1/read/model_families`](/reference/read/model_families) takes it as input


---
title: "ModelFamily"
description: "one family of quantitative model a market may be expressed in over the substrate: what it represents, the quantities it holds, what it reads from the record, what it gives, the solver that steps or solves it, and the check that proves it; a template names its family and a vertical chooses among them"
section: concepts
address: /concepts/modelfamily
contract: 0476e35e6e275db5
---

# ModelFamily

one family of quantitative model a market may be expressed in over the substrate: what it represents, the quantities it holds, what it reads from the record, what it gives, the solver that steps or solves it, and the check that proves it; a template names its family and a vertical chooses among them

[figure: ModelFamily is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | its name |
| store | postgres |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `what` | `text` | yes |  |
| `representation` | `one of stocks and flows \| a graph of participants and handovers \| a hypergraph of co-presence \| agents with behaviours \| a game of roles \| a learned latent model of the market` | yes |  |
| `substrate` | `text` | yes | the parts of the platform the model is written over and stepped on |
| `state_form` | `text` | yes | what one state of the model is, as rows |
| `quantities` | `[text]` | yes | the quantities the model holds, each a registered measure or a parameter |
| `reads` | `[text]` | yes | what it reads from the record, by kind |
| `gives` | `[text]` | yes | what a run gives, by kind |
| `solver` | `text` | yes | how a state becomes the next, or how the model is solved |
| `check` | `text` | yes | the check that proves a run right, with its planted fault |
| `fits_verticals` | `[text]` | yes | the vertical families it fits, by name; empty means every vertical |



## Routes that use it
No route takes or returns ModelFamily directly. The record holds it, and the objects that point at it reach it.


---
title: "ModelFlow"
description: "one flow of a systems model between two stocks, its rate a driver tree the one evaluator computes each step"
section: concepts
address: /concepts/modelflow
contract: 0476e35e6e275db5
---

# ModelFlow

one flow of a systems model between two stocks, its rate a driver tree the one evaluator computes each step

[figure: ModelFlow is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `from_stock` | `text` | yes |  |
| `to_stock` | `text` | yes |  |
| `rate` | [DriverNode](/concepts/drivernode) | yes | the units that move per step, as a tree over drivers |
| `roles` | [RoleAroundADecision](/concepts/rolearoundadecision) | yes | the roles that hand the unit on |
| `shape` | [CalculationShape](/concepts/calculationshape) | no | the calculation shape the flow's money follows, where it carries money |
| `selects` | `text` | no | the predicate, by name, that selects the units the flow moves |
| `delay` | `duration` | no | the delay before a moved unit counts |



## Routes that use it
No route takes or returns ModelFlow directly. The record holds it, and the objects that point at it reach it.


---
title: "ModelsInput"
description: "the vertical, the segment or the buyer profile whose business models are asked for; all three absent asks for every model"
section: concepts
address: /concepts/modelsinput
contract: 0476e35e6e275db5
---

# ModelsInput

the vertical, the segment or the buyer profile whose business models are asked for; all three absent asks for every model

[figure: ModelsInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | one ask for the business models |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `vertical` | `id` | no |  |
| `segment` | `id` | no |  |
| `kind_of_buyer` | `text` | no | the buyer profile's name |



## Routes that use it
- [`/v1/economics/models`](/reference/economics/models) takes it as input


---
title: "ModelStatistics"
description: "base rates, calibration by segment and version, interval coverage, and familiarity"
section: concepts
address: /concepts/modelstatistics
contract: 0476e35e6e275db5
---

# ModelStatistics

base rates, calibration by segment and version, interval coverage, and familiarity

[figure: ModelStatistics is a fact at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | platform |
| key | the model and the beat |
| store | postgres |
| family | models |



## Fields


| field | type | required | note |
|---|---|---|---|
| `base_rates` | `{text:share}` | yes |  |
| `calibration_by_segment` | `{text:share}` | yes |  |
| `interval_coverage` | `share` | yes |  |
| `familiarity_test` | [ControlResult](/concepts/controlresult) | yes |  |
| `floors` | `{text:share}` | yes |  |
| `read_at` | `time` | yes |  |



## Routes that use it
No route takes or returns ModelStatistics directly. The record holds it, and the objects that point at it reach it.


---
title: "ModelStock"
description: "one stock of a systems model: the units of one kind in one place, read from a chain stock where the chain holds one"
section: concepts
address: /concepts/modelstock
contract: 0476e35e6e275db5
---

# ModelStock

one stock of a systems model: the units of one kind in one place, read from a chain stock where the chain holds one

[figure: ModelStock is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `unit` | `text` | yes |  |
| `chain_stock` | `text` | no | the chain stock whose count starts it, by name |
| `initial` | [DriverNode](/concepts/drivernode) | no | how its starting level is read when no chain stock holds it |
| `reader` | `text` | yes | who reads it; a stock with no reader is a leak |
| `waiting` | `duration` | no | how long a unit may wait on it |



## Routes that use it
No route takes or returns ModelStock directly. The record holds it, and the objects that point at it reach it.


---
title: "Monitor"
description: "an armed condition that makes matches"
section: concepts
address: /concepts/monitor
contract: 0476e35e6e275db5
---

# Monitor

an armed condition that makes matches

[figure: Monitor is a definition at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | follows |
| key | its own id, versioned |
| store | postgres |
| family | rules_engine |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `predicate` | `hash` | yes | by its hash |
| `place` | [PlaceARunsAt](/concepts/placearunsat) | yes |  |
| `strategy` | `id` | yes | the brand's standing strategy unless one is chosen |
| `kind_of_signal` | [KindOfSignal](/concepts/kindofsignal) | yes |  |
| `armed` | `bool` | yes |  |
| `armed_with` | `id` | no | the preview its armed version was judged by |
| `last_answer` | [MonitorAnswer](/concepts/monitoranswer) | no | kept on every beat |
| `vertical` | `id` | no | for a platform monitor: the vertical it keeps full |



## Routes that use it
- [`/v1/act/arm_monitor`](/reference/act/arm_monitor) returns it
- [`/v1/act/keep_monitor`](/reference/act/keep_monitor) returns it


---
title: "MonitorAnswer"
description: "a monitor's answer on one beat"
section: concepts
address: /concepts/monitoranswer
contract: 0476e35e6e275db5
---

# MonitorAnswer

a monitor's answer on one beat

[figure: MonitorAnswer is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | rules_engine |



## Fields


| field | type | required | note |
|---|---|---|---|
| `at` | `time` | yes |  |
| `catches` | `count` | yes |  |
| `coverage` | [ChannelCoverage](/concepts/channelcoverage) | yes |  |
| `changed_since` | `text` | no |  |



## Routes that use it
No route takes or returns MonitorAnswer directly. The record holds it, and the objects that point at it reach it.


---
title: "MonitorPass"
description: "one pass of the beat that runs the armed monitors: every armed version read, the units of its place's population evaluated since the monitor's last answer, a catch written for each unit admitted at an observation not caught before, a signal ranked from each catch, and the monitor's last answer kept"
section: concepts
address: /concepts/monitorpass
contract: 0476e35e6e275db5
---

# MonitorPass

one pass of the beat that runs the armed monitors: every armed version read, the units of its place's population evaluated since the monitor's last answer, a catch written for each unit admitted at an observation not caught before, a signal ranked from each catch, and the monitor's last answer kept

[figure: MonitorPass is a work at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | work |
| scope | platform |
| key | the beat's tick |
| store | postgres |
| family | rules_engine |



## Fields


| field | type | required | note |
|---|---|---|---|
| `monitors` | `count` | yes | the armed versions run |
| `units_read` | `count` | yes |  |
| `catches` | `count` | yes | new catches |
| `signals` | `count` | yes | new signals |
| `not_evaluable` | `count` | yes | readings no condition could judge |
| `deferred` | `count` | yes | left for the next tick by the beat's budget |
| `tenants_served` | `count` | yes |  |
| `at` | `time` | yes |  |



## Routes that use it
No route takes or returns MonitorPass directly. The record holds it, and the objects that point at it reach it.


---
title: "MonitorStrengthInput"
description: "the monitor and a window"
section: concepts
address: /concepts/monitorstrengthinput
contract: 0476e35e6e275db5
---

# MonitorStrengthInput

the monitor and a window

[figure: MonitorStrengthInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `monitor` | `id` | yes |  |
| `window` | [Window](/concepts/window) | yes |  |



## Routes that use it
- [`/v1/read/monitor_strength`](/reference/read/monitor_strength) takes it as input


---
title: "Motive"
description: "one motive of a buyer profile or a router: its kind, its text and its evidence"
section: concepts
address: /concepts/motive
contract: 0476e35e6e275db5
---

# Motive

one motive of a buyer profile or a router: its kind, its text and its evidence

[figure: Motive is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `kind` | [KindOfMotive](/concepts/kindofmotive) | yes |  |
| `text` | `text` | yes |  |
| `evidence` | [EvidenceRef](/concepts/evidenceref) | yes | a motive with no evidence is a claim under test |



## Routes that use it
No route takes or returns Motive directly. The record holds it, and the objects that point at it reach it.


---
title: "Move"
description: "one proposed carrying out of a play: its forecast, its actions, its assignments, its effect"
section: concepts
address: /concepts/move
contract: 0476e35e6e275db5
---

# Move

one proposed carrying out of a play: its forecast, its actions, its assignments, its effect

[figure: Move is a work at strategy scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | work |
| scope | strategy |
| key | the play's version and the catch |
| store | postgres |
| family | strategy |



## Fields


| field | type | required | note |
|---|---|---|---|
| `play` | `id` | yes |  |
| `play_version` | `count` | yes |  |
| `vertex` | `text` | no | the vertex of the play's graph this move carries out; absent for a play whose graph is one move |
| `catch` | `id` | no |  |
| `kinds_of_action` | [KindOfAction](/concepts/kindofaction) | yes |  |
| `voice` | `id` | no |  |
| `what_is_said` | `text` | no |  |
| `proof` | `text` | no | the proof this buyer accepts |
| `price` | [Cost](/concepts/cost) | yes |  |
| `forecast` | [Forecast](/concepts/forecast) | no | withheld when there is no like population |
| `forecast_withheld_because` | `text` | no |  |
| `code` | `text` | no | the code it minted |
| `assignments` | [Assignment](/concepts/assignment) | yes |  |
| `actions` | `[id]` | yes |  |
| `effect` | [Effect](/concepts/effect) | no |  |
| `hypothesis` | `id` | no |  |
| `decided_by` | [Caller](/concepts/caller) | no |  |
| `frame` | [SaleFrame](/concepts/saleframe) | no | the sale framed for this buyer |
| `kind` | [KindOfMove](/concepts/kindofmove) | yes |  |
| `actor` | `id` | no | the Actor routed by propensity, or waiting to be assigned |
| `content` | `id` | no | the content chosen by propensity |
| `graph` | [GraphEdge](/concepts/graphedge) | yes | the edges between its actions; empty for a list |
| `propensities` | `[id]` | yes | the PropensityToMove facts that chose the actor and the content, with their odds |



## Routes that use it
- [`/v1/act/act_through_connector`](/reference/act/act_through_connector) returns it
- [`/v1/act/decide_move`](/reference/act/decide_move) returns it
- [`/v1/act/propose_move`](/reference/act/propose_move) returns it
- [`/v1/act/undo_action`](/reference/act/undo_action) returns it


---
title: "MovesPass"
description: "one pass of the beat that proposes the ready moves: every open instance of an armed play read, the vertices whose edges hold proposed under the instance's trigger, and the vertices held counted"
section: concepts
address: /concepts/movespass
contract: 0476e35e6e275db5
---

# MovesPass

one pass of the beat that proposes the ready moves: every open instance of an armed play read, the vertices whose edges hold proposed under the instance's trigger, and the vertices held counted

[figure: MovesPass is a work at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | work |
| scope | platform |
| key | the beat's tick |
| store | postgres |
| family | strategy |



## Fields


| field | type | required | note |
|---|---|---|---|
| `plays` | `count` | yes | the armed plays read |
| `instances` | `count` | yes | the open instances read |
| `proposed` | `count` | yes | moves proposed |
| `held` | `count` | yes | vertices held, their edges not holding or not evaluable |
| `at` | `time` | yes |  |



## Routes that use it
No route takes or returns MovesPass directly. The record holds it, and the objects that point at it reach it.


---
title: "MoveTrajectory"
description: "one move: its place, the items that carried it out, the readings of those items and its effect"
section: concepts
address: /concepts/movetrajectory
contract: 0476e35e6e275db5
---

# MoveTrajectory

one move: its place, the items that carried it out, the readings of those items and its effect

[figure: MoveTrajectory is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `move` | `id` | yes |  |
| `play` | `id` | yes |  |
| `place` | `text` | yes |  |
| `items` | `[id]` | yes |  |
| `readings` | [ReadingOfMeasure](/concepts/readingofmeasure) | yes |  |
| `effect` | [Effect](/concepts/effect) | no |  |



## Routes that use it
No route takes or returns MoveTrajectory directly. The record holds it, and the objects that point at it reach it.


---
title: "MyWork"
description: "every run the caller started that is still running"
section: concepts
address: /concepts/mywork
contract: 0476e35e6e275db5
---

# MyWork

every run the caller started that is still running

[figure: MyWork is a view at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `tasks` | [Task](/concepts/task) | yes |  |



## Routes that use it
- [`/v1/work/mine`](/reference/work/mine) returns it


---
title: "NamedProcedure"
description: "a written way of doing a recurring job, which the agent follows and a person can read"
section: concepts
address: /concepts/namedprocedure
contract: 0476e35e6e275db5
---

# NamedProcedure

a written way of doing a recurring job, which the agent follows and a person can read

[figure: NamedProcedure is a definition at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | platform |
| key | its name and version |
| store | postgres |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `steps` | `[text]` | yes |  |
| `plants` | `text` | no | for an acceptance procedure: the fault it plants |
| `must_read_red` | `text` | no |  |
| `must_read_green` | `text` | no |  |
| `population` | `text` | no |  |
| `control` | `text` | no |  |
| `code` | `text` | no | for a procedure the workbench runs: the script its steps run, as a path inside the workspace |
| `code_hash` | `hash` | no | the hash of the code as it ran; a number from code without it is never measured |



## Routes that use it
No route takes or returns NamedProcedure directly. The record holds it, and the objects that point at it reach it.


---
title: "NearnessBar"
description: "the bars of one breadth: the least similarity the name channel accepts and the least nearness the meaning channel accepts"
section: concepts
address: /concepts/nearnessbar
contract: 0476e35e6e275db5
---

# NearnessBar

the bars of one breadth: the least similarity the name channel accepts and the least nearness the meaning channel accepts

[figure: NearnessBar is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | rules_engine |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `share` | yes | the least trigram similarity of names the name channel accepts |
| `meaning` | `share` | yes | the least cosine nearness of vectors under the one model the meaning channel accepts |



## Routes that use it
No route takes or returns NearnessBar directly. The record holds it, and the objects that point at it reach it.


---
title: "NeighboursAnswer"
description: "the members one hop away, and whether the cap was reached"
section: concepts
address: /concepts/neighboursanswer
contract: 0476e35e6e275db5
---

# NeighboursAnswer

the members one hop away, and whether the cap was reached

[figure: NeighboursAnswer is a view at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `members` | [ConnectionMember](/concepts/connectionmember) | yes |  |
| `cap_reached` | `bool` | yes |  |
| `cap` | `count` | yes |  |



## Routes that use it
- [`/v1/ask/neighbours`](/reference/ask/neighbours) returns it


---
title: "NeighboursInput"
description: "an entity, one kind of connection, and the two dates"
section: concepts
address: /concepts/neighboursinput
contract: 0476e35e6e275db5
---

# NeighboursInput

an entity, one kind of connection, and the two dates

[figure: NeighboursInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `entity` | `id` | yes |  |
| `kind` | [KindOfConnection](/concepts/kindofconnection) | yes |  |
| `role` | `text` | no |  |



## Routes that use it
- [`/v1/ask/neighbours`](/reference/ask/neighbours) takes it as input


---
title: "NetworkPolicy"
description: "one allowed flow between two parties on the private network; everything not declared is denied"
section: concepts
address: /concepts/networkpolicy
contract: 0476e35e6e275db5
---

# NetworkPolicy

one allowed flow between two parties on the private network; everything not declared is denied

[figure: NetworkPolicy is a definition at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | platform |
| key | the source and the destination |
| store | postgres |
| family | network |



## Fields


| field | type | required | note |
|---|---|---|---|
| `from_role` | `text` | yes | a role, the ingress, the load balancer, or the internet |
| `to_role` | `text` | yes | a role, a store, the collector, or the internet |
| `port` | `count` | yes |  |
| `protocol` | `one of tcp \| udp` | yes |  |
| `reason` | `text` | yes | why the flow exists, in one sentence |



## Routes that use it
No route takes or returns NetworkPolicy directly. The record holds it, and the objects that point at it reach it.


---
title: "NetworkProxyPool"
description: "a pool of exits, ready or not ready with the reason; over its ceiling, its jobs are held"
section: concepts
address: /concepts/networkproxypool
contract: 0476e35e6e275db5
---

# NetworkProxyPool

a pool of exits, ready or not ready with the reason; over its ceiling, its jobs are held

[figure: NetworkProxyPool is a definition at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | platform |
| key | the provider, the kind and the country |
| store | postgres |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `provider` | [NetworkProxyProvider](/concepts/networkproxyprovider) | yes |  |
| `kind` | `one of none \| datacenter \| residential \| ISP \| mobile` | yes |  |
| `country` | `text` | no |  |
| `sticky` | `bool` | yes |  |
| `ceiling` | [Cost](/concepts/cost) | yes | of the receive family |
| `spend` | [Cost](/concepts/cost) | yes | read at the exit |
| `state` | [Readiness](/concepts/readiness) | yes |  |



## Routes that use it
No route takes or returns NetworkProxyPool directly. The record holds it, and the objects that point at it reach it.


---
title: "NetworkProxyProvider"
description: "a provider of network proxy exits, as a row and a credential; none is named in code"
section: concepts
address: /concepts/networkproxyprovider
contract: 0476e35e6e275db5
---

# NetworkProxyProvider

a provider of network proxy exits, as a row and a credential; none is named in code

[figure: NetworkProxyProvider is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | its name |
| store | postgres |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `endpoint` | `text` | yes |  |
| `credential` | `id` | yes |  |
| `pool_kinds` | `[one of datacenter \| residential \| ISP \| mobile]` | yes |  |
| `countries` | `[text]` | yes |  |
| `sticky_sessions` | `bool` | yes |  |
| `cost_per_gigabyte` | [Cost](/concepts/cost) | yes |  |



## Routes that use it
No route takes or returns NetworkProxyProvider directly. The record holds it, and the objects that point at it reach it.


---
title: "NextAction"
description: "what can be done next from a card"
section: concepts
address: /concepts/nextaction
contract: 0476e35e6e275db5
---

# NextAction

what can be done next from a card

[figure: NextAction is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `tool` | `text` | yes |  |
| `label` | `text` | yes |  |
| `input` | `json` | no |  |



## Routes that use it
No route takes or returns NextAction directly. The record holds it, and the objects that point at it reach it.


---
title: "NormalisationRule"
description: "how one extracted field becomes a typed value: trimmed text, a number with its unit, money with its currency, a date with its basis, a regular-expression capture, a map of words to a registered kind, or an entity looked up by identifier"
section: concepts
address: /concepts/normalisationrule
contract: 0476e35e6e275db5
---

# NormalisationRule

how one extracted field becomes a typed value: trimmed text, a number with its unit, money with its currency, a date with its basis, a regular-expression capture, a map of words to a registered kind, or an entity looked up by identifier

[figure: NormalisationRule is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `field` | `text` | yes |  |
| `kind` | `one of trim \| number with unit \| money with currency \| date with basis \| regex capture \| map to a kind \| lookup by identifier` | yes |  |
| `argument` | `text` | no | the unit, the currency, the basis, the pattern, the kind or the namespace |
| `required` | `bool` | yes | a row missing a required value is not ready with the reason |



## Routes that use it
No route takes or returns NormalisationRule directly. The record holds it, and the objects that point at it reach it.


---
title: "Nothing"
description: "an input with no fields"
section: concepts
address: /concepts/nothing
contract: 0476e35e6e275db5
---

# Nothing

an input with no fields

[figure: Nothing is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|




## Routes that use it
- [`/v1/session/my_scopes`](/reference/session/my_scopes) takes it as input
- [`/v1/session/sign_out`](/reference/session/sign_out) returns it
- [`/v1/read/instruction_set`](/reference/read/instruction_set) takes it as input
- [`/v1/read/invitations`](/reference/read/invitations) takes it as input
- [`/v1/read/predicate_language`](/reference/read/predicate_language) takes it as input
- [`/v1/view/capabilities`](/reference/view/capabilities) takes it as input
- [`/v1/act/export_tenant`](/reference/act/export_tenant) takes it as input
- [`/v1/work/cancel`](/reference/work/cancel) returns it
- [`/v1/work/mine`](/reference/work/mine) takes it as input
- [`/v1/files/list`](/reference/files/list) takes it as input
- [`/v1/files/workspace`](/reference/files/workspace) takes it as input


---
title: "Notification"
description: "a message that something needs a person, with the tool that resolves it"
section: concepts
address: /concepts/notification
contract: 0476e35e6e275db5
---

# Notification

a message that something needs a person, with the tool that resolves it

[figure: Notification is a work at user scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | work |
| scope | user |
| key | what and who |
| store | postgres |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `what` | `text` | yes |  |
| `why` | `text` | yes |  |
| `tool` | `text` | yes |  |
| `unit` | `id` | yes |  |
| `to` | `id` | yes |  |
| `passed_on_to` | `id` | no |  |
| `longest_wait` | `duration` | yes |  |



## Routes that use it
No route takes or returns Notification directly. The record holds it, and the objects that point at it reach it.


---
title: "NotificationChannel"
description: "where a notice goes: in the app, by email, in Slack, by webhook or in the browser extension, verified by a test notice before it carries one"
section: concepts
address: /concepts/notificationchannel
contract: 0476e35e6e275db5
---

# NotificationChannel

where a notice goes: in the app, by email, in Slack, by webhook or in the browser extension, verified by a test notice before it carries one

[figure: NotificationChannel is a row at tenant scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | tenant |
| key |  |
| store | postgres |
| family | leads |



## Fields


| field | type | required | note |
|---|---|---|---|
| `kind` | `one of in the app \| email \| Slack \| webhook \| the extension` | yes |  |
| `address` | `text` | yes |  |
| `owner` | `id` | yes | a person, or the tenant |
| `notices` | `[text]` | yes | the kinds of notice it carries |
| `verified` | `bool` | yes |  |
| `verified_at` | `time` | no |  |



## Routes that use it
- [`/v1/act/notification_channel`](/reference/act/notification_channel) returns it


---
title: "NotificationChannelInput"
description: "a channel to write: its kind, its address and the notices it carries"
section: concepts
address: /concepts/notificationchannelinput
contract: 0476e35e6e275db5
---

# NotificationChannelInput

a channel to write: its kind, its address and the notices it carries

[figure: NotificationChannelInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `kind` | `one of in the app \| email \| Slack \| webhook \| the extension` | yes |  |
| `address` | `text` | yes |  |
| `notices` | `[text]` | yes |  |



## Routes that use it
- [`/v1/act/notification_channel`](/reference/act/notification_channel) takes it as input


---
title: "NotificationRule"
description: "which notices go to which channel for whom, with quiet hours and a digest cadence; never what happens, only who is told"
section: concepts
address: /concepts/notificationrule
contract: 0476e35e6e275db5
---

# NotificationRule

which notices go to which channel for whom, with quiet hours and a digest cadence; never what happens, only who is told

[figure: NotificationRule is a definition at tenant scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | tenant |
| key | the person and the name |
| store | postgres |
| family | leads |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `notices` | `[text]` | yes |  |
| `channel` | [NotificationChannel](/concepts/notificationchannel) | yes |  |
| `for_person` | `id` | yes |  |
| `quiet_hours` | `text` | no | a range in the person's zone |
| `digest` | `one of none \| hourly \| daily` | yes |  |



## Routes that use it
- [`/v1/act/notification_rule`](/reference/act/notification_rule) returns it


---
title: "NotificationRuleInput"
description: "a rule to write: the notices, the channel, quiet hours and the digest"
section: concepts
address: /concepts/notificationruleinput
contract: 0476e35e6e275db5
---

# NotificationRuleInput

a rule to write: the notices, the channel, quiet hours and the digest

[figure: NotificationRuleInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `notices` | `[text]` | yes |  |
| `channel` | [NotificationChannel](/concepts/notificationchannel) | yes |  |
| `quiet_hours` | `text` | no |  |
| `digest` | `one of none \| hourly \| daily` | yes |  |



## Routes that use it
- [`/v1/act/notification_rule`](/reference/act/notification_rule) takes it as input


---
title: "NumberChange"
description: "one number that moved"
section: concepts
address: /concepts/numberchange
contract: 0476e35e6e275db5
---

# NumberChange

one number that moved

[figure: NumberChange is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | documents |



## Fields


| field | type | required | note |
|---|---|---|---|
| `label` | `text` | yes |  |
| `before` | `json` | yes |  |
| `after` | `json` | yes |  |
| `unit` | `id` | yes |  |



## Routes that use it
No route takes or returns NumberChange directly. The record holds it, and the objects that point at it reach it.


---
title: "NumberInPosition"
description: "one number in exactly one of three positions: a summary measured, an estimate with its interval, or a parameter stipulated"
section: concepts
address: /concepts/numberinposition
contract: 0476e35e6e275db5
---

# NumberInPosition

one number in exactly one of three positions: a summary measured, an estimate with its interval, or a parameter stipulated

[figure: NumberInPosition is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `summary` | [Summary](/concepts/summary) | no | measured |
| `estimate` | `id` | no | estimated, with its interval |
| `parameter` | `id` | no | stipulated, of the intend family |



## Routes that use it
No route takes or returns NumberInPosition directly. The record holds it, and the objects that point at it reach it.


---
title: "Observation"
description: "one version of a content item as read; the same version read again makes no second observation"
section: concepts
address: /concepts/observation
contract: 0476e35e6e275db5
---

# Observation

one version of a content item as read; the same version read again makes no second observation

[figure: Observation is a fact at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | follows |
| key | the row of silver it was made from |
| store | lake:ready |
| family | record |



## Fields


| field | type | required | note |
|---|---|---|---|
| `content_item` | `id` | yes |  |
| `text` | `text` | no |  |
| `text_hash` | `hash` | no |  |
| `hand_over` | `id` | yes |  |
| `row_of_silver` | `id` | yes |  |



## Routes that use it
No route takes or returns Observation directly. The record holds it, and the objects that point at it reach it.


---
title: "Offering"
description: "what a brand sells, with its structure and its prices as facts"
section: concepts
address: /concepts/offering
contract: 0476e35e6e275db5
---

# Offering

what a brand sells, with its structure and its prices as facts

[figure: Offering is a entity at shared scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | entity |
| scope | shared |
| key | the brand and its own name or address |
| store | postgres |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `brand` | `id` | yes |  |
| `name` | `text` | yes |  |
| `structure` | [OfferingStructure](/concepts/offeringstructure) | yes |  |
| `prices` | [Claim](/concepts/claim) | yes | a price is a claim with two times |
| `claims` | [Claim](/concepts/claim) | yes |  |
| `front_door` | `text` | no |  |



## Routes that use it
No route takes or returns Offering directly. The record holds it, and the objects that point at it reach it.


---
title: "OfferingFit"
description: "an offering that fits a lead, and why"
section: concepts
address: /concepts/offeringfit
contract: 0476e35e6e275db5
---

# OfferingFit

an offering that fits a lead, and why

[figure: OfferingFit is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | leads |



## Fields


| field | type | required | note |
|---|---|---|---|
| `offering` | `id` | yes |  |
| `why` | `text` | yes |  |
| `binding` | `id` | yes |  |



## Routes that use it
No route takes or returns OfferingFit directly. The record holds it, and the objects that point at it reach it.


---
title: "OfferingStructure"
description: "package, variant, part or complement"
section: concepts
address: /concepts/offeringstructure
contract: 0476e35e6e275db5
---

# OfferingStructure

package, variant, part or complement

[figure: OfferingStructure is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `kind` | `one of package \| variant \| part \| complement` | yes |  |
| `other` | `id` | yes |  |
| `quantity` | `count` | no | how many of the part a kit holds |



## Routes that use it
No route takes or returns OfferingStructure directly. The record holds it, and the objects that point at it reach it.


---
title: "Oldest"
description: "the oldest unit in a place, with its reason"
section: concepts
address: /concepts/oldest
contract: 0476e35e6e275db5
---

# Oldest

the oldest unit in a place, with its reason

[figure: Oldest is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | ops_console |



## Fields


| field | type | required | note |
|---|---|---|---|
| `unit` | `id` | yes |  |
| `since` | `time` | yes |  |
| `reason` | `text` | yes |  |



## Routes that use it
No route takes or returns Oldest directly. The record holds it, and the objects that point at it reach it.


---
title: "OldestInput"
description: "a place: OldestInput, a value of the harness family at none scope"
section: concepts
address: /concepts/oldestinput
contract: 0476e35e6e275db5
---

# OldestInput

a place: OldestInput, a value of the harness family at none scope

[figure: OldestInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `kind` | [Kind](/concepts/kind) | yes |  |
| `place` | `text` | yes |  |



## Routes that use it
- [`/v1/view/oldest`](/reference/view/oldest) takes it as input


---
title: "Operation"
description: "one tool as the API serves it: a route, its input and output as owning types, its errors, its limits; generated"
section: concepts
address: /concepts/operation
contract: 0476e35e6e275db5
---

# Operation

one tool as the API serves it: a route, its input and output as owning types, its errors, its limits; generated

[figure: Operation is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | the tool |
| store | postgres |
| family | gateway |



## Fields


| field | type | required | note |
|---|---|---|---|
| `tool` | [Tool](/concepts/tool) | yes |  |
| `verb` | [Verb](/concepts/verb) | yes |  |
| `route` | `text` | yes |  |
| `method` | `one of GET \| POST` | yes |  |
| `input_type` | `text` | yes |  |
| `output_type` | `text` | yes |  |
| `errors` | `[text]` | yes | each a Refusal with its rule |
| `limits` | [RateBound](/concepts/ratebound) | yes |  |
| `idempotent` | `bool` | yes | a change carries its idempotency key |
| `version` | `text` | yes | the API's version |



## Routes that use it
No route takes or returns Operation directly. The record holds it, and the objects that point at it reach it.


---
title: "Operator"
description: "an operator or a comparator of the closed language, as a row"
section: concepts
address: /concepts/operator
contract: 0476e35e6e275db5
---

# Operator

an operator or a comparator of the closed language, as a row

[figure: Operator is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | its name |
| store | postgres |
| family | rules_engine |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `plain_words` | `text` | yes | the words a composer shows for the operator, in the buyers' own language; a row without them fails the register's check |
| `form` | `one of condition \| operator node \| group` | yes |  |
| `slots` | [OperatorSlot](/concepts/operatorslot) | yes | each with the type of its value |
| `cost_class` | `one of cheap \| scan \| semantic \| walk` | yes |  |
| `keeps_state` | `bool` | yes |  |
| `register_hash` | `hash` | yes |  |
| `accepts` | `[text]` | no | for a comparator, the value types of the attribute it admits, from the closed list of SourceField types |
| `rhs` | `one of none \| scalar \| many \| range \| relative window` | no | for a comparator, the shape of its right-hand value |
| `label` | `text` | no | the words the composer shows for it |
| `can_trigger` | `bool` | no | whether a unit this operator admits can by itself make a match; a tree with no such leaf cannot arm |



## Routes that use it
No route takes or returns Operator directly. The record holds it, and the objects that point at it reach it.


---
title: "OperatorSlot"
description: "one slot of an operator"
section: concepts
address: /concepts/operatorslot
contract: 0476e35e6e275db5
---

# OperatorSlot

one slot of an operator

[figure: OperatorSlot is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | rules_engine |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `value_type` | `one of text \| number \| time \| duration \| list \| concept \| proxy \| connection kind \| subject \| threshold \| the attribute's own \| range \| choice \| population \| bool \| breadth` | yes | the attribute's own is the type of the attribute compared; a range is two ends of that type, the lower first; a choice is one of the slot's choices; a population names a row of populations; a breadth is one of exact, similar, related or broad, resolved at compile to the leaf's channel bar of the bars of nearness, and a threshold slot beside it is its alternative, exactly one given |
| `required` | `bool` | yes |  |
| `required_when` | `text` | no | the condition under which an optional slot becomes required, in words |
| `choices` | `[text]` | no | for a choice slot, its closed list |
| `whole` | `bool` | no | for a number slot, whether the value must be a whole number |
| `limits` | `[number]` | no | for a number slot, the lowest and the highest value allowed, two numbers |



## Routes that use it
No route takes or returns OperatorSlot directly. The record holds it, and the objects that point at it reach it.


---
title: "Outcome"
description: "a condition as marked, by whom and when; measured and never guessed"
section: concepts
address: /concepts/outcome
contract: 0476e35e6e275db5
---

# Outcome

a condition as marked, by whom and when; measured and never guessed

[figure: Outcome is a fact at brand scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | brand |
| key | the lead, the condition and the moment |
| store | postgres+lake |
| family | leads |



## Fields


| field | type | required | note |
|---|---|---|---|
| `lead` | `id` | yes |  |
| `condition` | [LeadCondition](/concepts/leadcondition) | yes |  |
| `reason` | `text` | no |  |
| `marked_by` | [Caller](/concepts/caller) | yes |  |



## Routes that use it
- [`/v1/act/mark_lead`](/reference/act/mark_lead) returns it


---
title: "Package"
description: "the lead as handed to a person: why it is a lead, who this buyer is, which offerings fit, the moves to choose from"
section: concepts
address: /concepts/package
contract: 0476e35e6e275db5
---

# Package

the lead as handed to a person: why it is a lead, who this buyer is, which offerings fit, the moves to choose from

[figure: Package is a view at brand scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | brand |
| key | the lead and the receiver |
| store | derived |
| family | leads |



## Fields


| field | type | required | note |
|---|---|---|---|
| `lead` | `id` | yes |  |
| `committee` | [ConnectionMember](/concepts/connectionmember) | yes | where known |
| `why` | [EvidenceRef](/concepts/evidenceref) | yes | walked back to the sentence |
| `kind_of_buyer` | `id` | yes |  |
| `offerings_that_fit` | [OfferingFit](/concepts/offeringfit) | yes |  |
| `moves` | `[id]` | yes | each with its forecast and interval |
| `as_of` | [TwoDates](/concepts/twodates) | yes |  |
| `fit` | [FitScore](/concepts/fitscore) | no | the fit with its interval |
| `criteria` | [CriterionVerdict](/concepts/criterionverdict) | no | each criterion with its highlights |
| `explanation` | [Explanation](/concepts/explanation) | no | from the highlighted evidence alone |
| `temperature` | `one of hot \| warm \| cold` | no |  |
| `temperature_reason` | `text` | no |  |
| `observations` | [EvidenceRef](/concepts/evidenceref) | no | every observation read |



## Routes that use it
No route takes or returns Package directly. The record holds it, and the objects that point at it reach it.


---
title: "PageChange"
description: "a market event of the kind page changed: what was added, removed or changed between two versions of a page, and the extracted fields that moved"
section: concepts
address: /concepts/pagechange
contract: 0476e35e6e275db5
---

# PageChange

a market event of the kind page changed: what was added, removed or changed between two versions of a page, and the extracted fields that moved

[figure: PageChange is a fact at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | follows |
| key | the page, the previous version and the new version |
| store | lake:ready |
| family | record |



## Fields


| field | type | required | note |
|---|---|---|---|
| `page` | `id` | yes | the content item |
| `previous_version` | `count` | yes |  |
| `new_version` | `count` | yes |  |
| `kind` | `one of added \| removed \| changed \| moved \| sitemap entry added \| sitemap entry removed` | yes |  |
| `diff_summary` | `text` | yes |  |
| `changed_fields` | `{text:json}` | yes | old and new by field |
| `seen_at` | `time` | yes |  |
| `watch` | `id` | no |  |



## Routes that use it
No route takes or returns PageChange directly. The record holds it, and the objects that point at it reach it.


---
title: "PageChangesInput"
description: "page changes for a site or a watch in a window"
section: concepts
address: /concepts/pagechangesinput
contract: 0476e35e6e275db5
---

# PageChangesInput

page changes for a site or a watch in a window

[figure: PageChangesInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `site` | `id` | no |  |
| `watch` | `id` | no |  |
| `window` | [Window](/concepts/window) | yes |  |



## Routes that use it
- [`/v1/read/page_changes`](/reference/read/page_changes) takes it as input


---
title: "PageContact"
description: "one contact a page showed, by a contact kind: the value as shown, the value as identity compares it, and where it came from"
section: concepts
address: /concepts/pagecontact
contract: 0476e35e6e275db5
---

# PageContact

one contact a page showed, by a contact kind: the value as shown, the value as identity compares it, and where it came from

[figure: PageContact is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `kind` | `text` | yes |  |
| `namespace` | `text` | yes |  |
| `value` | `text` | yes |  |
| `normalised` | `text` | yes |  |
| `basis` | `text` | yes |  |
| `trust_rank` | `count` | yes |  |



## Routes that use it
No route takes or returns PageContact directly. The record holds it, and the objects that point at it reach it.


---
title: "PageField"
description: "one form field a page showed, with what it held when the page was read: its label, its name, its kind, its value, and whether the person changed it; a password, a one-time code and a card's number never appear, by the platform's redaction rows"
section: concepts
address: /concepts/pagefield
contract: 0476e35e6e275db5
---

# PageField

one form field a page showed, with what it held when the page was read: its label, its name, its kind, its value, and whether the person changed it; a password, a one-time code and a card's number never appear, by the platform's redaction rows

[figure: PageField is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `label` | `text` | yes | the field's label, its placeholder or its name, as the page shows it |
| `name` | `text` | no | the field's own name on the page |
| `kind` | `text` | yes | the input's type, a text area, a choice, or an editable region |
| `value` | `text` | yes | what the field held, cut to 4,000 characters |
| `dirty` | `bool` | yes | the person typed or chose it, and it differs from what the page loaded with |
| `form` | `text` | no | the form it belongs to, by its name or the address it posts to |
| `recipient` | `bool` | no | the field names who a message goes to |



## Routes that use it
No route takes or returns PageField directly. The record holds it, and the objects that point at it reach it.


---
title: "PageHints"
description: "how a page was read and what was kept out"
section: concepts
address: /concepts/pagehints
contract: 0476e35e6e275db5
---

# PageHints

how a page was read and what was kept out

[figure: PageHints is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `text_truncated` | `bool` | yes |  |
| `links_truncated` | `bool` | yes |  |
| `capture_method` | `one of selected_tab_visible_text \| selected_tab_scrolled \| selected_tab_ambient \| fetched_static` | yes |  |
| `network_events_captured` | `bool` | yes |  |
| `redacted_fields` | `count` | yes |  |
| `redacted_addresses` | `count` | yes |  |
| `redacted_patterns` | `count` | yes |  |
| `rounds` | `count` | no |  |
| `items` | `count` | no |  |
| `stopped_by` | `text` | no |  |
| `trigger` | `one of say-so \| a submit \| leaving the page \| the page settled \| a timer` | no | what made a capture under a rule |
| `events_dropped` | `count` | no | network events past the bound or outside the filters |



## Routes that use it
No route takes or returns PageHints directly. The record holds it, and the objects that point at it reach it.


---
title: "PageLayer"
description: "a dialog, menu or viewer open on the page when it was read, read as its own region: its kind, its title, the visible text, its links and how many items it listed; what a reveal of the domain binds to"
section: concepts
address: /concepts/pagelayer
contract: 0476e35e6e275db5
---

# PageLayer

a dialog, menu or viewer open on the page when it was read, read as its own region: its kind, its title, the visible text, its links and how many items it listed; what a reveal of the domain binds to

[figure: PageLayer is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `kind` | `one of dialog \| menu \| expanded \| viewer` | yes |  |
| `title` | `text` | yes |  |
| `labelled_by` | `text` | no | the id or label the page gave the region |
| `text` | `text` | yes |  |
| `links` | [PageLink](/concepts/pagelink) | yes |  |
| `items` | `count` | yes | the list items inside it |



## Routes that use it
No route takes or returns PageLayer directly. The record holds it, and the objects that point at it reach it.


---
title: "PageLink"
description: "one visible link of a page"
section: concepts
address: /concepts/pagelink
contract: 0476e35e6e275db5
---

# PageLink

one visible link of a page

[figure: PageLink is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `url` | `text` | yes |  |
| `text` | `text` | yes |  |
| `aria` | `text` | no |  |



## Routes that use it
No route takes or returns PageLink directly. The record holds it, and the objects that point at it reach it.


---
title: "PageMeasure"
description: "one count a page showed, read as a registered kind of measure: likes, comments, views, stars, downloads, followers, applicants and every other engagement a page shows, with the number as shown and as a number, and where it came from; it becomes a reading of the measure on the page's subject"
section: concepts
address: /concepts/pagemeasure
contract: 0476e35e6e275db5
---

# PageMeasure

one count a page showed, read as a registered kind of measure: likes, comments, views, stars, downloads, followers, applicants and every other engagement a page shows, with the number as shown and as a number, and where it came from; it becomes a reading of the measure on the page's subject

[figure: PageMeasure is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `measure` | [KindOfMeasure](/concepts/kindofmeasure) | yes | the kind of measure's name |
| `value` | `number` | yes | the number, with thousands and millions expanded |
| `shown` | `text` | yes | the count as the page showed it |
| `basis` | `text` | yes | the template field, the structured data, or the words beside the count |
| `selector` | `text` | no |  |
| `item` | `text` | no | the item of a list the count belongs to, by its own id, when it is not the page's subject's |



## Routes that use it
No route takes or returns PageMeasure directly. The record holds it, and the objects that point at it reach it.


---
title: "PageMiss"
description: "one template field a reader could not read: what it should have been and what the page showed where it was expected"
section: concepts
address: /concepts/pagemiss
contract: 0476e35e6e275db5
---

# PageMiss

one template field a reader could not read: what it should have been and what the page showed where it was expected

[figure: PageMiss is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `field` | `text` | yes |  |
| `type` | `text` | yes |  |
| `selector` | `text` | yes |  |
| `expected` | `text` | yes |  |
| `nearest` | `text` | yes | the page's own markup around the place, with every form field removed |



## Routes that use it
No route takes or returns PageMiss directly. The record holds it, and the objects that point at it reach it.


---
title: "PageNetworkEvent"
description: "one call the page made or one frame it received while a capture rule was on, as the page hook in the main world saw it: its kind, its method and address, the status, and the bodies sent and received, cut to a bound; never a header, a cookie or a credential"
section: concepts
address: /concepts/pagenetworkevent
contract: 0476e35e6e275db5
---

# PageNetworkEvent

one call the page made or one frame it received while a capture rule was on, as the page hook in the main world saw it: its kind, its method and address, the status, and the bodies sent and received, cut to a bound; never a header, a cookie or a credential

[figure: PageNetworkEvent is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `at` | `time` | yes |  |
| `kind` | `one of fetch \| xhr \| websocket in \| websocket out \| beacon \| form post` | yes |  |
| `method` | `text` | no |  |
| `url` | `text` | yes | the address with session keys removed |
| `status` | `count` | no |  |
| `request_body` | `text` | no | the body sent, with secret fields removed |
| `response_body` | `text` | no | the body received |
| `bytes` | `count` | yes | the bytes seen, before any cut |
| `truncated` | `bool` | yes |  |
| `duration_ms` | `count` | no |  |
| `step` | `count` | no | the index of the step that caused it, when one did |



## Routes that use it
No route takes or returns PageNetworkEvent directly. The record holds it, and the objects that point at it reach it.


---
title: "PageProperty"
description: "one property a page template read: its name, its label, its value, where it came from and, for a list, how many items it holds"
section: concepts
address: /concepts/pageproperty
contract: 0476e35e6e275db5
---

# PageProperty

one property a page template read: its name, its label, its value, where it came from and, for a list, how many items it holds

[figure: PageProperty is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `label` | `text` | yes |  |
| `value` | `text` | yes | a list lands as JSON text |
| `basis` | `text` | yes |  |
| `selector` | `text` | no |  |
| `truncated` | `bool` | no |  |
| `items` | `count` | no |  |



## Routes that use it
No route takes or returns PageProperty directly. The record holds it, and the objects that point at it reach it.


---
title: "PageReading"
description: "a page as a reader read it, the document a capture carries and a walk deposits: the address, the title, the visible text, the headings and links, the properties the template read, the contacts the page showed, the fields not read, the template, and how it was read; the extension and the walk make the same shape"
section: concepts
address: /concepts/pagereading
contract: 0476e35e6e275db5
---

# PageReading

a page as a reader read it, the document a capture carries and a walk deposits: the address, the title, the visible text, the headings and links, the properties the template read, the contacts the page showed, the fields not read, the template, and how it was read; the extension and the walk make the same shape

[figure: PageReading is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `actual_url` | `text` | yes |  |
| `title` | `text` | yes |  |
| `main_text` | `text` | yes |  |
| `headings` | `[text]` | yes |  |
| `links` | [PageLink](/concepts/pagelink) | yes |  |
| `outcome` | `one of readable_loaded \| empty_or_blocked \| rate_limited` | yes |  |
| `outcome_reason` | `text` | no |  |
| `properties` | [PageProperty](/concepts/pageproperty) | yes |  |
| `contact_links` | [PageLink](/concepts/pagelink) | yes | mail, telephone and message links, kept apart |
| `contacts` | [PageContact](/concepts/pagecontact) | yes |  |
| `misses` | [PageMiss](/concepts/pagemiss) | yes |  |
| `template` | `text` | no | the extraction template that read the page |
| `logo_image` | `text` | no |  |
| `captured_at` | `time` | yes |  |
| `page_hints` | [PageHints](/concepts/pagehints) | yes |  |
| `annotations` | [Annotation](/concepts/annotation) | no | what the person said about the page while capturing it |
| `fields` | [PageField](/concepts/pagefield) | no | the form fields the page showed, with what the person typed |
| `engagement` | [PageMeasure](/concepts/pagemeasure) | no | the counts the page showed |
| `network_events` | [PageNetworkEvent](/concepts/pagenetworkevent) | no | the calls the page made while a rule was on |
| `layers` | [PageLayer](/concepts/pagelayer) | no | the dialogs and menus open when the page was read, each read as its own region |
| `steps` | [BrowsingStep](/concepts/browsingstep) | no | what the person did on the page, in order, while a rule was on |
| `session` | `text` | no | the page's own session: one opening of one page in one tab, so readings of one visit join |



## Routes that use it
No route takes or returns PageReading directly. The record holds it, and the objects that point at it reach it.


---
title: "Pairing"
description: "two kinds the product needs together, the rule that joins them, and the sentence shown when one is missing"
section: concepts
address: /concepts/pairing
contract: 0476e35e6e275db5
---

# Pairing

two kinds the product needs together, the rule that joins them, and the sentence shown when one is missing

[figure: Pairing is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | the two kinds |
| store | postgres |
| family | ops_console |



## Fields


| field | type | required | note |
|---|---|---|---|
| `first` | [Kind](/concepts/kind) | yes |  |
| `second` | [Kind](/concepts/kind) | yes |  |
| `rule` | `text` | yes |  |
| `sentence` | `text` | yes |  |



## Routes that use it
No route takes or returns Pairing directly. The record holds it, and the objects that point at it reach it.


---
title: "PairingReading"
description: "one pairing and the units that lack their pair"
section: concepts
address: /concepts/pairingreading
contract: 0476e35e6e275db5
---

# PairingReading

one pairing and the units that lack their pair

[figure: PairingReading is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `pairing` | [Pairing](/concepts/pairing) | yes |  |
| `lacking` | [UnitRef](/concepts/unitref) | yes |  |
| `count` | `count` | yes |  |



## Routes that use it
No route takes or returns PairingReading directly. The record holds it, and the objects that point at it reach it.


---
title: "PairingsAnswer"
description: "each pairing, with the units that lack their pair"
section: concepts
address: /concepts/pairingsanswer
contract: 0476e35e6e275db5
---

# PairingsAnswer

each pairing, with the units that lack their pair

[figure: PairingsAnswer is a view at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `pairings` | [PairingReading](/concepts/pairingreading) | yes |  |



## Routes that use it
- [`/v1/view/pairings`](/reference/view/pairings) returns it


---
title: "PairingsInput"
description: "a scope: PairingsInput, a value of the harness family at none scope"
section: concepts
address: /concepts/pairingsinput
contract: 0476e35e6e275db5
---

# PairingsInput

a scope: PairingsInput, a value of the harness family at none scope

[figure: PairingsInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `scope` | [Scope](/concepts/scope) | yes |  |



## Routes that use it
- [`/v1/view/pairings`](/reference/view/pairings) takes it as input


---
title: "Parameter"
description: "a named number or choice a reader or a law uses; data a person can change from the console"
section: concepts
address: /concepts/parameter
contract: 0476e35e6e275db5
---

# Parameter

a named number or choice a reader or a law uses; data a person can change from the console

[figure: Parameter is a parameter at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | parameter |
| scope | platform |
| key | its name and where it is set |
| store | postgres |
| family | kernel |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `family` | `one of intend \| machinery \| receive \| source` | yes |  |
| `dimension` | `text` | yes |  |
| `value` | `json` | yes |  |
| `set_at_scope` | [Scope](/concepts/scope) | yes |  |
| `enforced_at` | `text` | yes |  |
| `version` | `count` | yes |  |
| `changed_by` | [Caller](/concepts/caller) | no |  |



## Routes that use it
- [`/v1/read/parameter`](/reference/read/parameter) returns it
- [`/v1/act/parameter`](/reference/act/parameter) returns it


---
title: "ParameterInput"
description: "a parameter by name and where it is set"
section: concepts
address: /concepts/parameterinput
contract: 0476e35e6e275db5
---

# ParameterInput

a parameter by name and where it is set

[figure: ParameterInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `scope` | [Scope](/concepts/scope) | no |  |



## Routes that use it
- [`/v1/read/parameter`](/reference/read/parameter) takes it as input


---
title: "ParameterWriteInput"
description: "a parameter of the record written from the console or by a person's own tool: its name, its value and the scope it is set at"
section: concepts
address: /concepts/parameterwriteinput
contract: 0476e35e6e275db5
---

# ParameterWriteInput

a parameter of the record written from the console or by a person's own tool: its name, its value and the scope it is set at

[figure: ParameterWriteInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `value` | `json` | yes |  |
| `scope` | [Scope](/concepts/scope) | no | the caller's tenant when absent |



## Routes that use it
- [`/v1/act/parameter`](/reference/act/parameter) takes it as input


---
title: "PartialAnswer"
description: "which bound was reached, what was dropped, and which way that biases the count"
section: concepts
address: /concepts/partialanswer
contract: 0476e35e6e275db5
---

# PartialAnswer

which bound was reached, what was dropped, and which way that biases the count

[figure: PartialAnswer is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | rules_engine |



## Fields


| field | type | required | note |
|---|---|---|---|
| `bound` | `one of units \| time \| expansion` | yes |  |
| `dropped` | `text` | yes |  |
| `bias` | `one of an upper bound \| a lower bound \| neither` | yes |  |



## Routes that use it
No route takes or returns PartialAnswer directly. The record holds it, and the objects that point at it reach it.


---
title: "ParticipantImpact"
description: "the nature of one participant's impact on another role of the chain"
section: concepts
address: /concepts/participantimpact
contract: 0476e35e6e275db5
---

# ParticipantImpact

the nature of one participant's impact on another role of the chain

[figure: ParticipantImpact is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `on` | [RoleAroundADecision](/concepts/rolearoundadecision) | yes |  |
| `nature` | `one of gates \| refers \| supplies \| competes \| informs \| pays \| regulates \| hosts \| delivers` | yes |  |
| `strength` | [Summary](/concepts/summary) | no | where read |
| `note` | `text` | no |  |



## Routes that use it
No route takes or returns ParticipantImpact directly. The record holds it, and the objects that point at it reach it.


---
title: "Parting"
description: "a later fact that ends a merge, restoring both sides"
section: concepts
address: /concepts/parting
contract: 0476e35e6e275db5
---

# Parting

a later fact that ends a merge, restoring both sides

[figure: Parting is a fact at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | follows |
| key | the merge it ends |
| store | postgres+lake |
| family | identity |



## Fields


| field | type | required | note |
|---|---|---|---|
| `merge` | `id` | yes |  |
| `decision` | `id` | yes |  |
| `facts_written_again` | `[id]` | yes |  |



## Routes that use it
No route takes or returns Parting directly. The record holds it, and the objects that point at it reach it.


---
title: "PartitionHandover"
description: "what the engine hands the record"
section: concepts
address: /concepts/partitionhandover
contract: 0476e35e6e275db5
---

# PartitionHandover

what the engine hands the record

[figure: PartitionHandover is a work at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | work |
| scope | follows |
| key | the closed partition, or the job's result |
| store | postgres |
| family | record |



## Fields


| field | type | required | note |
|---|---|---|---|
| `partition` | `id` | no |  |
| `job_result` | `id` | no |  |
| `asks_served` | `[id]` | yes |  |
| `tries` | `count` | yes |  |



## Routes that use it
No route takes or returns PartitionHandover directly. The record holds it, and the objects that point at it reach it.


---
title: "PendingCapture"
description: "a capture the extension holds until the core accepts it: keyed like the capture, with its bytes, attempts and state"
section: concepts
address: /concepts/pendingcapture
contract: 0476e35e6e275db5
---

# PendingCapture

a capture the extension holds until the core accepts it: keyed like the capture, with its bytes, attempts and state

[figure: PendingCapture is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `key` | `hash` | yes | the artefact's hash with the person and the time |
| `scope` | `one of this item \| this thread \| this channel as shown \| this page \| this meeting \| my outbound message` | yes |  |
| `under` | `one of say-so \| rule` | yes |  |
| `rule` | `id` | no |  |
| `bytes` | `bytes` | yes |  |
| `attempts` | `count` | yes |  |
| `state` | `one of pending \| sent \| accepted \| rejected` | yes | the extension's own state, never a place of the record |
| `reason` | `text` | no |  |



## Routes that use it
No route takes or returns PendingCapture directly. The record holds it, and the objects that point at it reach it.


---
title: "Permission"
description: "the smallest thing that can be allowed: one verb on one kind of thing; generated, never written by hand"
section: concepts
address: /concepts/permission
contract: 0476e35e6e275db5
---

# Permission

the smallest thing that can be allowed: one verb on one kind of thing; generated, never written by hand

[figure: Permission is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | the verb and the kind |
| store | postgres |
| family | people |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes | the reading's or the kind of action's own name, which a grant and an access scope name |
| `verb` | `text` | yes | the family of the call: read, ask, act, work, session, files |
| `kind` | [Kind](/concepts/kind) | yes | the kind the call gives |
| `from_row` | `text` | yes | the reading or the kind of action that brought it |



## Routes that use it
No route takes or returns Permission directly. The record holds it, and the objects that point at it reach it.


---
title: "PermissionAnswer"
description: "the typed answer of the permission check before any action, which the acting function takes as an argument"
section: concepts
address: /concepts/permissionanswer
contract: 0476e35e6e275db5
---

# PermissionAnswer

the typed answer of the permission check before any action, which the acting function takes as an argument

[figure: PermissionAnswer is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | people |



## Fields


| field | type | required | note |
|---|---|---|---|
| `allowed` | `bool` | yes |  |
| `mode` | `one of read only \| propose \| act \| full autonomy` | no |  |
| `failed_test` | `one of 1 \| 2 \| 3 \| 4 \| 5` | no |  |
| `refusal` | [Refusal](/concepts/refusal) | no |  |
| `grant` | `id` | no | the narrowest grant that covers it |
| `limits_left` | [GrantLimits](/concepts/grantlimits) | no |  |



## Routes that use it
No route takes or returns PermissionAnswer directly. The record holds it, and the objects that point at it reach it.


---
title: "PermissionHeld"
description: "a registration, a licence, an approval or a certification one party holds in one country in one role, as a regulator's register records it"
section: concepts
address: /concepts/permissionheld
contract: 0476e35e6e275db5
---

# PermissionHeld

a registration, a licence, an approval or a certification one party holds in one country in one role, as a regulator's register records it

[figure: PermissionHeld is a fact at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | follows |
| key | the holder, the register and the identifier |
| store | postgres |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `holder` | `id` | yes | the entity |
| `kind` | `one of registration \| licence \| approval \| certification` | yes |  |
| `register` | `id` | yes | the source, a regulator's register |
| `identifier` | `text` | yes | as the register writes it |
| `country` | `text` | yes |  |
| `role` | `one of maker \| importer \| distributor \| licensee \| operator \| affiliate \| provider \| payer` | yes |  |
| `since` | `date` | yes |  |
| `until` | `date` | no |  |
| `evidence` | [EvidenceRef](/concepts/evidenceref) | yes |  |



## Routes that use it
No route takes or returns PermissionHeld directly. The record holds it, and the objects that point at it reach it.


---
title: "Place"
description: "one position a unit of a kind can be in"
section: concepts
address: /concepts/place
contract: 0476e35e6e275db5
---

# Place

one position a unit of a kind can be in

[figure: Place is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | the kind and its name |
| store | postgres |
| family | kernel |



## Fields


| field | type | required | note |
|---|---|---|---|
| `kind` | [Kind](/concepts/kind) | yes |  |
| `name` | `text` | yes |  |
| `resting` | `bool` | yes | a resting place is declared, and has no reader |
| `reader` | `text` | no | the durable work that moves units out, or a person |
| `longest_wait` | `duration` | no | past which the view counts the unit |
| `who_is_told` | `text` | no | when the longest wait passes |



## Routes that use it
No route takes or returns Place directly. The record holds it, and the objects that point at it reach it.


---
title: "PlaceARunsAt"
description: "a place a predicate runs: the population it reads, what an admitted unit makes, and who owns it"
section: concepts
address: /concepts/placearunsat
contract: 0476e35e6e275db5
---

# PlaceARunsAt

a place a predicate runs: the population it reads, what an admitted unit makes, and who owns it

[figure: PlaceARunsAt is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | its name |
| store | postgres |
| family | rules_engine |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `population` | [Population](/concepts/population) | yes |  |
| `makes` | [Kind](/concepts/kind) | yes |  |
| `owner` | `text` | yes | the part that owns what is made |



## Routes that use it
No route takes or returns PlaceARunsAt directly. The record holds it, and the objects that point at it reach it.


---
title: "PlaceParticipantInput"
description: "a party placed in a role on a stock of a vertical's chain"
section: concepts
address: /concepts/placeparticipantinput
contract: 0476e35e6e275db5
---

# PlaceParticipantInput

a party placed in a role on a stock of a vertical's chain

[figure: PlaceParticipantInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `vertical` | `id` | yes |  |
| `segment` | `id` | no |  |
| `stock` | `text` | yes |  |
| `party` | `id` | yes |  |
| `party_kind` | `one of company \| brand \| person \| account \| community \| organisation` | yes |  |
| `role` | [RoleAroundADecision](/concepts/rolearoundadecision) | yes |  |
| `side` | `one of demand \| supply \| intermediary \| influence \| rules` | yes |  |
| `impact_on` | [ParticipantImpact](/concepts/participantimpact) | no |  |
| `evidence` | [EvidenceRef](/concepts/evidenceref) | yes |  |



## Routes that use it
- [`/v1/act/place_participant`](/reference/act/place_participant) takes it as input


---
title: "PlanChange"
description: "a plan change as a proposal, with the provider's own page for payment"
section: concepts
address: /concepts/planchange
contract: 0476e35e6e275db5
---

# PlanChange

a plan change as a proposal, with the provider's own page for payment

[figure: PlanChange is a view at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `proposal` | `id` | yes |  |
| `payment_page` | `address` | no |  |



## Routes that use it
- [`/v1/act/change_plan`](/reference/act/change_plan) returns it


---
title: "Plane"
description: "shared, one tenant's, or the platform's own; part of the type of a fact"
section: concepts
address: /concepts/plane
contract: 0476e35e6e275db5
---

# Plane

shared, one tenant's, or the platform's own; part of the type of a fact

[figure: Plane is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | kernel |



## Fields


| field | type | required | note |
|---|---|---|---|
| `plane` | `one of shared \| tenant \| platform` | yes |  |
| `tenant` | `id` | no | required for tenant |



## Routes that use it
No route takes or returns Plane directly. The record holds it, and the objects that point at it reach it.


---
title: "PlanReport"
description: "did I do what I planned: one row per play, then the items done off plan"
section: concepts
address: /concepts/planreport
contract: 0476e35e6e275db5
---

# PlanReport

did I do what I planned: one row per play, then the items done off plan

[figure: PlanReport is a view at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `rows` | [PlanReportRow](/concepts/planreportrow) | yes |  |
| `window` | [Window](/concepts/window) | yes |  |



## Routes that use it
- [`/v1/read/plan_report`](/reference/read/plan_report) returns it


---
title: "PlanReportInput"
description: "a strategy and a window"
section: concepts
address: /concepts/planreportinput
contract: 0476e35e6e275db5
---

# PlanReportInput

a strategy and a window

[figure: PlanReportInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `strategy` | `id` | yes |  |
| `window` | [Window](/concepts/window) | no |  |



## Routes that use it
- [`/v1/read/plan_report`](/reference/read/plan_report) takes it as input


---
title: "PlanReportRow"
description: "one play of the strategy against what was done: completed, partial, missing, or an item done off any plan"
section: concepts
address: /concepts/planreportrow
contract: 0476e35e6e275db5
---

# PlanReportRow

one play of the strategy against what was done: completed, partial, missing, or an item done off any plan

[figure: PlanReportRow is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `play` | `id` | no |  |
| `move` | `id` | no |  |
| `state` | `one of completed \| partial \| missing \| off plan` | yes |  |
| `items` | `[id]` | yes |  |
| `why` | `text` | yes |  |



## Routes that use it
No route takes or returns PlanReportRow directly. The record holds it, and the objects that point at it reach it.


---
title: "PlatformApiObject"
description: "one object of a platform's API: the addresses that answer it, what it yields, the paths read from its JSON and the lists it carries"
section: concepts
address: /concepts/platformapiobject
contract: 0476e35e6e275db5
---

# PlatformApiObject

one object of a platform's API: the addresses that answer it, what it yields, the paths read from its JSON and the lists it carries

[figure: PlatformApiObject is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `address_patterns` | `[text]` | yes |  |
| `yields` | `text` | yes |  |
| `fields` | [FieldSpec](/concepts/fieldspec) | yes |  |
| `lists` | [PlatformList](/concepts/platformlist) | yes |  |
| `needs` | `one of anyone \| signed in \| connected \| member \| admin \| premium \| licensed` | yes | what the viewer must be for the call to answer as described |



## Routes that use it
No route takes or returns PlatformApiObject directly. The record holds it, and the objects that point at it reach it.


---
title: "PlatformDomain"
description: "a platform's world as one row the capture side is generated from: its things and the kinds they become, how they relate, its pages and its API objects with what each yields and the lists each carries, what its properties name, and what feeds a signal; the platform's sources, the browser connector's declaration, the…"
section: concepts
address: /concepts/platformdomain
contract: 0476e35e6e275db5
---

# PlatformDomain

a platform's world as one row the capture side is generated from: its things and the kinds they become, how they relate, its pages and its API objects with what each yields and the lists each carries, what its properties name, and what feeds a signal; the platform's sources, the browser connector's declaration, the…

[figure: PlatformDomain is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | the platform |
| store | postgres |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `platform` | `text` | yes | the slug; the row's key |
| `name` | `text` | yes |  |
| `host` | `text` | yes |  |
| `address_patterns` | `[text]` | yes |  |
| `tint` | `text` | no |  |
| `mark_drawn` | `bool` | yes |  |
| `things` | [PlatformThing](/concepts/platformthing) | yes |  |
| `relations` | [PlatformRelation](/concepts/platformrelation) | yes |  |
| `pages` | [PlatformPage](/concepts/platformpage) | yes |  |
| `reveals` | [PlatformReveal](/concepts/platformreveal) | yes | the controls on its pages that show more |
| `api` | [PlatformApiObject](/concepts/platformapiobject) | yes |  |
| `network_events` | [ResourceFilter](/concepts/resourcefilter) | yes |  |
| `mentions` | [PlatformMention](/concepts/platformmention) | yes |  |
| `signals` | [PlatformSignal](/concepts/platformsignal) | yes |  |
| `session` | [SessionMaterial](/concepts/sessionmaterial) | no | what a signed-in identity on this platform keeps and how the platform tells that it is signed in; absent for a platform with no signed-in reading |
| `version` | `text` | yes |  |
| `state` | [Readiness](/concepts/readiness) | yes |  |
| `legality_tier` | `text` | no | the legality tier of pages a person opens on this platform, as ruled for the tenant; absent until ruled, and the browser source stays not ready |
| `standing_grant` | `bool` | no | whether the extension holds a standing site grant for this platform after the store review, so a person on its pages is not asked again; false or absent for every other platform, whose grant is optional and asked for on the person's own act |



## Routes that use it
No route takes or returns PlatformDomain directly. The record holds it, and the objects that point at it reach it.


---
title: "PlatformList"
description: "a list a page or an API answer carries whose items are things of the platform, each keyed by the first of its key paths that holds a value, and the relation between the page's thing and each item"
section: concepts
address: /concepts/platformlist
contract: 0476e35e6e275db5
---

# PlatformList

a list a page or an API answer carries whose items are things of the platform, each keyed by the first of its key paths that holds a value, and the relation between the page's thing and each item

[figure: PlatformList is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `field` | `text` | yes |  |
| `thing` | `text` | yes | a thing of the domain |
| `relation` | `text` | no | a relation of the domain; absent when the items stand alone |
| `key_paths` | `[text]` | yes |  |
| `name_path` | `text` | no |  |
| `items_are_from` | `bool` | yes | true when each item takes the relation's from role and the page's thing its to role; false the other way round |
| `parent` | [PlatformListParent](/concepts/platformlistparent) | no | the thing each item belongs to, when the item carries its key: a comment's post, an edition's newsletter |
| `needs` | `one of anyone \| signed in \| connected \| member \| admin \| premium \| licensed` | yes | what the viewer must be to see the list at all |



## Routes that use it
No route takes or returns PlatformList directly. The record holds it, and the objects that point at it reach it.


---
title: "PlatformListParent"
description: "the thing an item of a list belongs to, in the platform's words: the item field that carries the parent's key, the parent thing, and the relation from the item to it"
section: concepts
address: /concepts/platformlistparent
contract: 0476e35e6e275db5
---

# PlatformListParent

the thing an item of a list belongs to, in the platform's words: the item field that carries the parent's key, the parent thing, and the relation from the item to it

[figure: PlatformListParent is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `field` | `text` | yes | the item field that carries the parent's key |
| `thing` | `text` | yes | a thing of the domain |
| `relation` | `text` | yes | a relation of the domain whose from side is the item's thing and whose to side is the parent's |



## Routes that use it
No route takes or returns PlatformListParent directly. The record holds it, and the objects that point at it reach it.


---
title: "PlatformMention"
description: "what kind of thing a property names on this platform"
section: concepts
address: /concepts/platformmention
contract: 0476e35e6e275db5
---

# PlatformMention

what kind of thing a property names on this platform

[figure: PlatformMention is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `property` | `text` | yes |  |
| `kind` | [KindOfEntity](/concepts/kindofentity) | yes |  |



## Routes that use it
No route takes or returns PlatformMention directly. The record holds it, and the objects that point at it reach it.


---
title: "PlatformPage"
description: "one kind of page of a platform: what it yields, how it is read, the lists it carries, whether it pages through a next link, and what the viewer must be to see it"
section: concepts
address: /concepts/platformpage
contract: 0476e35e6e275db5
---

# PlatformPage

one kind of page of a platform: what it yields, how it is read, the lists it carries, whether it pages through a next link, and what the viewer must be to see it

[figure: PlatformPage is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `address_patterns` | `[text]` | yes |  |
| `deny_patterns` | `[text]` | no | the addresses under this page's patterns that are not this kind of page (an edit form, a details page, an overlay), which the page's template scope denies |
| `yields` | `text` | yes | a thing of the domain |
| `render` | `one of static \| auto \| rendered` | yes |  |
| `fields` | [FieldSpec](/concepts/fieldspec) | yes |  |
| `lists` | [PlatformList](/concepts/platformlist) | yes |  |
| `paged` | `bool` | yes |  |
| `scrolls` | `text` | no | the list the reader scrolls before it reads, until nothing new appears; absent when the page shows everything at once |
| `needs` | `one of anyone \| signed in \| connected \| member \| admin \| premium \| licensed` | yes | what the viewer must be to see the page as described; a page shows less to a viewer below it, and the capture records what it saw |



## Routes that use it
No route takes or returns PlatformPage directly. The record holds it, and the objects that point at it reach it.


---
title: "PlatformRelation"
description: "one way two things of a platform relate, and the registered kind of connection it becomes with the role each side takes"
section: concepts
address: /concepts/platformrelation
contract: 0476e35e6e275db5
---

# PlatformRelation

one way two things of a platform relate, and the registered kind of connection it becomes with the role each side takes

[figure: PlatformRelation is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes | the platform's word: follows, stars, contributes to, member of |
| `kind` | [KindOfConnection](/concepts/kindofconnection) | yes |  |
| `from_thing` | `text` | yes |  |
| `from_role` | `text` | yes |  |
| `to_thing` | `text` | yes |  |
| `to_role` | `text` | yes |  |



## Routes that use it
No route takes or returns PlatformRelation directly. The record holds it, and the objects that point at it reach it.


---
title: "PlatformReveal"
description: "one control on a kind of page that shows more without leaving it, or leads to the page that holds the rest: what a person clicks, what opens, where what opens is drawn from (the page's own data, another page of the domain, an API object the click calls, or nothing kept), the fields and lists read inside it, and…"
section: concepts
address: /concepts/platformreveal
contract: 0476e35e6e275db5
---

# PlatformReveal

one control on a kind of page that shows more without leaving it, or leads to the page that holds the rest: what a person clicks, what opens, where what opens is drawn from (the page's own data, another page of the domain, an API object the click calls, or nothing kept), the fields and lists read inside it, and…

[figure: PlatformReveal is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `page` | `text` | yes | a page of the domain |
| `trigger` | `text` | yes | the control's label as the platform shows it, such as Show all or N reactions |
| `selector` | `text` | no | how the reader finds the control |
| `opens` | `one of dialog \| menu \| expanded \| page \| viewer` | yes |  |
| `source` | `one of the page \| a page \| an API object \| none` | yes | where what opens is drawn from |
| `source_name` | `text` | no | the page or API object of the domain, when the source is one |
| `fields` | [FieldSpec](/concepts/fieldspec) | yes | read inside what opens, when it is drawn from the page |
| `lists` | [PlatformList](/concepts/platformlist) | yes | the lists what opens carries, such as the people who reacted |
| `needs` | `one of anyone \| signed in \| connected \| member \| admin \| premium \| licensed` | yes |  |
| `note` | `text` | no |  |



## Routes that use it
No route takes or returns PlatformReveal directly. The record holds it, and the objects that point at it reach it.


---
title: "PlatformSignal"
description: "a signal kind the platform's things, relations or measures feed, with what on the platform means it"
section: concepts
address: /concepts/platformsignal
contract: 0476e35e6e275db5
---

# PlatformSignal

a signal kind the platform's things, relations or measures feed, with what on the platform means it

[figure: PlatformSignal is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `signal` | [KindOfSignal](/concepts/kindofsignal) | yes |  |
| `from_thing` | `text` | no |  |
| `from_relation` | `text` | no |  |
| `from_measure` | [KindOfMeasure](/concepts/kindofmeasure) | no |  |
| `meaning` | `text` | yes |  |



## Routes that use it
No route takes or returns PlatformSignal directly. The record holds it, and the objects that point at it reach it.


---
title: "PlatformState"
description: "every service with its life, every reader's distance behind the log, events set aside, settings changed, cost by kind"
section: concepts
address: /concepts/platformstate
contract: 0476e35e6e275db5
---

# PlatformState

every service with its life, every reader's distance behind the log, events set aside, settings changed, cost by kind

[figure: PlatformState is a view at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | platform |
| key | the moment |
| store | derived |
| family | ops_console |



## Fields


| field | type | required | note |
|---|---|---|---|
| `services` | [RunningService](/concepts/runningservice) | yes |  |
| `readers_behind` | `{text:count}` | yes |  |
| `events_set_aside` | [Event](/concepts/event) | yes |  |
| `settings_changed` | [Event](/concepts/event) | yes |  |
| `cost_by_kind` | [Cost](/concepts/cost) | yes |  |



## Routes that use it
No route takes or returns PlatformState directly. The record holds it, and the objects that point at it reach it.


---
title: "PlatformThing"
description: "one kind of thing a platform holds, in the platform's own words, and the registered kind it becomes: its key on the platform, the fields kept as long texts, the fields that are outbound links, and the counts it shows"
section: concepts
address: /concepts/platformthing
contract: 0476e35e6e275db5
---

# PlatformThing

one kind of thing a platform holds, in the platform's own words, and the registered kind it becomes: its key on the platform, the fields kept as long texts, the fields that are outbound links, and the counts it shows

[figure: PlatformThing is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes | the platform's word: user profile, organisation profile, repository, package, job posting |
| `becomes` | [KindOfEntity](/concepts/kindofentity) | yes |  |
| `key_namespace` | `text` | yes | the identifier namespace of the thing's own key on the platform |
| `key_prefix` | `text` | no | the prefix the key carries, such as github: |
| `key_field` | `text` | yes | the field that carries the key on its pages and in the API |
| `texts` | `[text]` | yes | the fields kept as long texts |
| `links` | `[text]` | yes | the fields that are outbound links |
| `measures` | [KindOfMeasure](/concepts/kindofmeasure) | yes | the counts the thing shows |
| `note` | `text` | no |  |



## Routes that use it
No route takes or returns PlatformThing directly. The record holds it, and the objects that point at it reach it.


---
title: "Play"
description: "written once, filled per brand: its goal, condition, class, tactic, the move it proposes, its price, its measure, its forecast rule, its comparison, when it stops"
section: concepts
address: /concepts/play
contract: 0476e35e6e275db5
---

# Play

written once, filled per brand: its goal, condition, class, tactic, the move it proposes, its price, its measure, its forecast rule, its comparison, when it stops

[figure: Play is a definition at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | follows |
| key | its name and version |
| store | postgres |
| family | strategy |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `brand` | `id` | yes | the brand the play is filled for; a platform original is copied per brand with original set |
| `strategy` | `id` | no | the strategy it is armed in; absent until armed |
| `goal` | `id` | yes |  |
| `condition` | [Predicate](/concepts/predicate) | yes |  |
| `class` | [PlayClass](/concepts/playclass) | yes | the class last read on the beat (ClassReading); proposed on the arming from the kind's usual class and the rivals' coverage, never typed by taste |
| `tactic` | [Tactic](/concepts/tactic) | yes |  |
| `proposes` | `text` | yes | the move |
| `price` | [Cost](/concepts/cost) | no |  |
| `measure` | [KindOfMeasure](/concepts/kindofmeasure) | yes |  |
| `window` | `duration` | yes |  |
| `forecast_rule` | `text` | yes | how its forecast is made |
| `comparison` | `text` | yes | what is left alone |
| `stop` | `text` | yes |  |
| `armed` | `bool` | yes |  |
| `original` | `id` | no | a platform original in a template |
| `mode` | `one of harvest \| cultivate` | no | a harvest play for present demand, a cultivation play for demand to be made |
| `fit_phase` | `one of find the market \| sculpt the offering \| test the fit \| build a beachhead \| engineer demand \| find demand \| grow in a market \| hedge` | no | the phase of the search for product-market fit the play serves, where it serves one (26 §2.1) |
| `kind` | [KindOfPlay](/concepts/kindofplay) | no | the kind of play it is, from the register of kinds of play (26 §2.1) |
| `kind_of_move` | [KindOfMove](/concepts/kindofmove) | yes | the kind of move it proposes |
| `graph` | [GraphEdge](/concepts/graphedge) | yes | the edges between the moves it proposes; empty for a play of one move |
| `share` | `share` | yes | the share of the admitted members the arming admits; under one, the play is an experiment |
| `holdout` | `share` | yes | the share left alone at random, read as the effect's comparison |
| `trigger` | `one of a match \| a beat \| a person's word` | yes | what starts the play when no edge enters it |



## Routes that use it
- [`/v1/act/keep_play`](/reference/act/keep_play) returns it


---
title: "PlayClass"
description: "one class a play reads against the rivals and the tide: table stakes, benchmark, beta, alpha, expansion or hedge; a class is a hypothesis read on the beat, never typed"
section: concepts
address: /concepts/playclass
contract: 0476e35e6e275db5
---

# PlayClass

one class a play reads against the rivals and the tide: table stakes, benchmark, beta, alpha, expansion or hedge; a class is a hypothesis read on the beat, never typed

[figure: PlayClass is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | its name |
| store | postgres |
| family | strategy |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `order` | `count` | yes |  |
| `what` | `text` | yes |  |
| `assigned_by` | `text` | yes | the reading that assigns it |
| `decays_to` | [PlayClass](/concepts/playclass) | no | the class it falls to as the rivals copy it |
| `measure` | `text` | yes | what is read to assign it |
| `in_the_sources_words` | `text` | yes |  |



## Routes that use it
No route takes or returns PlayClass directly. The record holds it, and the objects that point at it reach it.


---
title: "Pole"
description: "one pole of a language scale"
section: concepts
address: /concepts/pole
contract: 0476e35e6e275db5
---

# Pole

one pole of a language scale

[figure: Pole is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | rules_engine |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `phrases` | `[text]` | yes |  |



## Routes that use it
No route takes or returns Pole directly. The record holds it, and the objects that point at it reach it.


---
title: "Policy"
description: "a rule that chooses among the ready arms of a strategy, a play, an actor or a content, and logs the odds of its choice; a tenant may choose another row and replay it on the history first"
section: concepts
address: /concepts/policy
contract: 0476e35e6e275db5
---

# Policy

a rule that chooses among the ready arms of a strategy, a play, an actor or a content, and logs the odds of its choice; a tenant may choose another row and replay it on the history first

[figure: Policy is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | its name and version |
| store | postgres |
| family | strategy |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `version` | `text` | yes |  |
| `what` | `text` | yes |  |
| `chooses` | `text` | yes |  |
| `default` | `bool` | yes |  |
| `source` | `text` | yes |  |



## Routes that use it
No route takes or returns Policy directly. The record holds it, and the objects that point at it reach it.


---
title: "PolicyDecision"
description: "the choice made, the chance it had, the alternatives, the version of the policy, the outcome when read"
section: concepts
address: /concepts/policydecision
contract: 0476e35e6e275db5
---

# PolicyDecision

the choice made, the chance it had, the alternatives, the version of the policy, the outcome when read

[figure: PolicyDecision is a fact at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | follows |
| key | the policy, its version and the moment |
| store | postgres+lake |
| family | models |



## Fields


| field | type | required | note |
|---|---|---|---|
| `policy` | `text` | yes |  |
| `version` | `text` | yes |  |
| `choice` | `json` | yes |  |
| `chance` | `chance` | yes |  |
| `alternatives` | `[json]` | yes |  |
| `outcome` | `json` | no |  |



## Routes that use it
No route takes or returns PolicyDecision directly. The record holds it, and the objects that point at it reach it.


---
title: "PolicyReplay"
description: "a policy replayed on the history before it changes anything"
section: concepts
address: /concepts/policyreplay
contract: 0476e35e6e275db5
---

# PolicyReplay

a policy replayed on the history before it changes anything

[figure: PolicyReplay is a view at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `policy` | [Policy](/concepts/policy) | yes |  |
| `strategy` | `id` | yes |  |
| `window` | [Window](/concepts/window) | yes |  |
| `rows` | [PolicyReplayRow](/concepts/policyreplayrow) | yes |  |
| `agreed` | `count` | yes | decisions where the replayed policy chose the same |
| `differed` | `count` | yes |  |



## Routes that use it
- [`/v1/read/policy_replay`](/reference/read/policy_replay) returns it


---
title: "PolicyReplayInput"
description: "a policy and its version replayed on a strategy's logged decisions over a window"
section: concepts
address: /concepts/policyreplayinput
contract: 0476e35e6e275db5
---

# PolicyReplayInput

a policy and its version replayed on a strategy's logged decisions over a window

[figure: PolicyReplayInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `policy` | [Policy](/concepts/policy) | yes |  |
| `strategy` | `id` | yes |  |
| `window` | [Window](/concepts/window) | no |  |



## Routes that use it
- [`/v1/read/policy_replay`](/reference/read/policy_replay) takes it as input


---
title: "PolicyReplayRow"
description: "one logged decision: what was chosen with its odds, what the replayed policy would have chosen, and the effect that followed"
section: concepts
address: /concepts/policyreplayrow
contract: 0476e35e6e275db5
---

# PolicyReplayRow

one logged decision: what was chosen with its odds, what the replayed policy would have chosen, and the effect that followed

[figure: PolicyReplayRow is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `decision` | `id` | yes |  |
| `chosen` | `json` | yes |  |
| `odds` | `chance` | yes |  |
| `would_choose` | `json` | yes |  |
| `effect` | [Effect](/concepts/effect) | no |  |



## Routes that use it
No route takes or returns PolicyReplayRow directly. The record holds it, and the objects that point at it reach it.


---
title: "Population"
description: "what a predicate runs over, with the reader that serves it at each speed"
section: concepts
address: /concepts/population
contract: 0476e35e6e275db5
---

# Population

what a predicate runs over, with the reader that serves it at each speed

[figure: Population is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | its name |
| store | postgres |
| family | rules_engine |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `unit_kind` | [Kind](/concepts/kind) | yes |  |
| `readers` | `{text:text}` | yes | for each speed of the preview and for live evaluation |
| `state` | [Readiness](/concepts/readiness) | yes | a population with no reader is not ready |
| `sample_strata` | `[text]` | no | the attribute paths whose values stratify a preview's sample, so the sample is spread over them |



## Routes that use it
No route takes or returns Population directly. The record holds it, and the objects that point at it reach it.


---
title: "PopulationAttributes"
description: "the attributes a population's units carry, read from the units themselves in one bounded scan, so a composer offers only what the record holds and a strata choice rests on counts"
section: concepts
address: /concepts/populationattributes
contract: 0476e35e6e275db5
---

# PopulationAttributes

the attributes a population's units carry, read from the units themselves in one bounded scan, so a composer offers only what the record holds and a strata choice rests on counts

[figure: PopulationAttributes is a view at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | none |
| key | none |
| store | none |
| family | rules_engine |



## Fields


| field | type | required | note |
|---|---|---|---|
| `population` | [Population](/concepts/population) | yes |  |
| `units_read` | `count` | yes |  |
| `units_in` | `count` | yes |  |
| `partial` | [PartialAnswer](/concepts/partialanswer) | no | when the budget ran out |
| `attributes` | [AttributeCount](/concepts/attributecount) | yes | most carried first |
| `as_of` | `time` | yes |  |



## Routes that use it
- [`/v1/read/attributes`](/reference/read/attributes) returns it


---
title: "PopulationStatement"
description: "the required statement of the population an answer was read over"
section: concepts
address: /concepts/populationstatement
contract: 0476e35e6e275db5
---

# PopulationStatement

the required statement of the population an answer was read over

[figure: PopulationStatement is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | rules_engine |



## Fields


| field | type | required | note |
|---|---|---|---|
| `store` | `one of the working set \| the refined layer \| the whole record \| a served table` | yes |  |
| `window` | [Window](/concepts/window) | yes |  |
| `units_in` | `count` | yes |  |
| `units_scanned` | `count` | yes |  |
| `channels` | [Source](/concepts/source) | yes | every channel of the tenant |



## Routes that use it
No route takes or returns PopulationStatement directly. The record holds it, and the objects that point at it reach it.


---
title: "PossibleMatch"
description: "two entities that may be one; they stay two until it is settled"
section: concepts
address: /concepts/possiblematch
contract: 0476e35e6e275db5
---

# PossibleMatch

two entities that may be one; they stay two until it is settled

[figure: PossibleMatch is a work at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | work |
| scope | follows |
| key | the pair of entities, in a fixed order |
| store | postgres |
| family | identity |



## Fields


| field | type | required | note |
|---|---|---|---|
| `first` | `id` | yes |  |
| `second` | `id` | yes |  |
| `chance` | `chance` | yes |  |
| `evidence` | [EvidenceRef](/concepts/evidenceref) | yes |  |
| `what_would_settle_it` | `text` | yes |  |
| `hypothesis` | `id` | yes | its claim under test |



## Routes that use it
No route takes or returns PossibleMatch directly. The record holds it, and the objects that point at it reach it.


---
title: "PostureInput"
description: "a community and the window"
section: concepts
address: /concepts/postureinput
contract: 0476e35e6e275db5
---

# PostureInput

a community and the window

[figure: PostureInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `community` | `id` | yes |  |
| `window` | [Window](/concepts/window) | no |  |



## Routes that use it
- [`/v1/read/posture`](/reference/read/posture) takes it as input


---
title: "Predicate"
description: "the tree, of three forms, over a population; an edit is a new predicate"
section: concepts
address: /concepts/predicate
contract: 0476e35e6e275db5
---

# Predicate

the tree, of three forms, over a population; an edit is a new predicate

[figure: Predicate is a definition at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | follows |
| key | the hash of its tree |
| store | postgres |
| family | rules_engine |



## Fields


| field | type | required | note |
|---|---|---|---|
| `tree` | [PredicateNode](/concepts/predicatenode) | yes |  |
| `population` | [Population](/concepts/population) | yes |  |
| `tree_hash` | `hash` | yes |  |
| `register_hash` | `hash` | yes | the register it was written against |
| `compiler_version` | `text` | yes |  |
| `comparator_versions` | `{text:text}` | yes | each comparator's register hash, and under the key the bars of nearness the version of that parameter row the breadths resolved against |
| `summary_versions` | `{text:count}` | no | of each summary its right-hand sides name |
| `nearness` | `{text:share}` | no | for each leaf that names a breadth, keyed by the leaf's hash, the bar it resolved to under the bars of nearness at the version comparator_versions records; frozen, so a changed row never moves an armed predicate |
| `sentence` | `text` | no | the sentence a person would say |



## Routes that use it
No route takes or returns Predicate directly. The record holds it, and the objects that point at it reach it.


---
title: "PredicateBudgets"
description: "how far a predicate may expand, how much state it may keep, how large it may be, how many semantic leaves a tenant may arm"
section: concepts
address: /concepts/predicatebudgets
contract: 0476e35e6e275db5
---

# PredicateBudgets

how far a predicate may expand, how much state it may keep, how large it may be, how many semantic leaves a tenant may arm

[figure: PredicateBudgets is a parameter at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | parameter |
| scope | platform |
| key | none |
| store | postgres |
| family | rules_engine |



## Fields


| field | type | required | note |
|---|---|---|---|
| `expansion` | `count` | yes |  |
| `state` | `bytes` | yes |  |
| `size` | `count` | yes |  |
| `semantic_leaves_armed` | `count` | yes |  |



## Routes that use it
No route takes or returns PredicateBudgets directly. The record holds it, and the objects that point at it reach it.


---
title: "PredicateLanguage"
description: "the operators, the comparators and the value types, with the hash"
section: concepts
address: /concepts/predicatelanguage
contract: 0476e35e6e275db5
---

# PredicateLanguage

the operators, the comparators and the value types, with the hash

[figure: PredicateLanguage is a view at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `operators` | [Operator](/concepts/operator) | yes |  |
| `populations` | [Population](/concepts/population) | yes |  |
| `hash` | `hash` | yes |  |



## Routes that use it
- [`/v1/read/predicate_language`](/reference/read/predicate_language) returns it


---
title: "PredicateNode"
description: "one node of a predicate: a group, a condition or an operator node"
section: concepts
address: /concepts/predicatenode
contract: 0476e35e6e275db5
---

# PredicateNode

one node of a predicate: a group, a condition or an operator node

[figure: PredicateNode is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | rules_engine |



## Fields


| field | type | required | note |
|---|---|---|---|
| `form` | `one of group \| condition \| operator node` | yes |  |
| `op` | `one of all \| any \| none` | no | for a group |
| `children` | [PredicateNode](/concepts/predicatenode) | no | for a group |
| `subject` | `text` | no | for a condition: the field or the subject |
| `relationship` | [Operator](/concepts/operator) | no |  |
| `value` | `json` | no |  |
| `threshold` | `share` | no | for a leaf that compares by nearness, a match by name or a semantic leaf by meaning: its floor, in place of a breadth |
| `breadth` | `one of exact \| similar \| related \| broad` | no | for a leaf that compares by nearness: how near, in place of a floor; resolved at compile to the leaf's channel bar of the bars of nearness (06 §2.1) |
| `concept` | `id` | no | a semantic leaf names a concept, never a phrase |
| `walks` | [KindOfConnection](/concepts/kindofconnection) | no | for an operator node: the connection it walks, by role |
| `role` | `text` | no |  |
| `inner` | [PredicateNode](/concepts/predicatenode) | no |  |



## Routes that use it
No route takes or returns PredicateNode directly. The record holds it, and the objects that point at it reach it.


---
title: "PreviewAnswer"
description: "the one typed answer of a preview, at any speed"
section: concepts
address: /concepts/previewanswer
contract: 0476e35e6e275db5
---

# PreviewAnswer

the one typed answer of a preview, at any speed

[figure: PreviewAnswer is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | rules_engine |



## Fields


| field | type | required | note |
|---|---|---|---|
| `count` | `count` | no | measured; there is no slot for a number when nothing was evaluated |
| `evaluated` | `bool` | yes |  |
| `coverage` | [ChannelCoverage](/concepts/channelcoverage) | yes |  |
| `population` | [PopulationStatement](/concepts/populationstatement) | yes |  |
| `not_evaluable` | `{text:count}` | yes | for each condition, beside the count |
| `limits` | `[text]` | yes |  |
| `partial` | [PartialAnswer](/concepts/partialanswer) | no |  |
| `founded` | `one of measured \| projected \| degraded` | yes | never better than the weakest thing it read |
| `speed` | `one of instant \| the last seven days \| the whole record` | yes |  |
| `predicate_hash` | `hash` | yes |  |
| `as_of` | [TwoDates](/concepts/twodates) | yes |  |
| `task` | `id` | no | for the third speed |
| `sample` | [PreviewSample](/concepts/previewsample) | no | a representative sample of the units that matched, spread over the population's strata |



## Routes that use it
- [`/v1/ask/preview`](/reference/ask/preview) returns it


---
title: "PreviewBudgets"
description: "the budget of each speed of the preview, enforced at the preview and nowhere else"
section: concepts
address: /concepts/previewbudgets
contract: 0476e35e6e275db5
---

# PreviewBudgets

the budget of each speed of the preview, enforced at the preview and nowhere else

[figure: PreviewBudgets is a parameter at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | parameter |
| scope | platform |
| key | none |
| store | postgres |
| family | rules_engine |



## Fields


| field | type | required | note |
|---|---|---|---|
| `instant` | [SpeedBudget](/concepts/speedbudget) | yes |  |
| `last_seven_days` | [SpeedBudget](/concepts/speedbudget) | yes |  |
| `whole_record` | [SpeedBudget](/concepts/speedbudget) | yes |  |



## Routes that use it
No route takes or returns PreviewBudgets directly. The record holds it, and the objects that point at it reach it.


---
title: "PreviewInput"
description: "a predicate or its hash, the place, the window, the speeds wanted, and the surface it calls from"
section: concepts
address: /concepts/previewinput
contract: 0476e35e6e275db5
---

# PreviewInput

a predicate or its hash, the place, the window, the speeds wanted, and the surface it calls from

[figure: PreviewInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `predicate` | [Predicate](/concepts/predicate) | no |  |
| `predicate_hash` | `hash` | no |  |
| `place` | [PlaceARunsAt](/concepts/placearunsat) | yes |  |
| `window` | [Window](/concepts/window) | yes |  |
| `speeds` | `[one of instant \| the last seven days \| the whole record]` | yes |  |



## Routes that use it
- [`/v1/ask/preview`](/reference/ask/preview) takes it as input


---
title: "PreviewSample"
description: "a representative sample of the units a predicate matched: at most the asked number, spread over the population's strata in proportion with at least one from each stratum that matched, chosen by the hash of the unit so the same predicate gives the same sample"
section: concepts
address: /concepts/previewsample
contract: 0476e35e6e275db5
---

# PreviewSample

a representative sample of the units a predicate matched: at most the asked number, spread over the population's strata in proportion with at least one from each stratum that matched, chosen by the hash of the unit so the same predicate gives the same sample

[figure: PreviewSample is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | rules_engine |



## Fields


| field | type | required | note |
|---|---|---|---|
| `units` | [SampleUnit](/concepts/sampleunit) | yes |  |
| `strata` | [SampleStratum](/concepts/samplestratum) | yes |  |
| `asked` | `count` | yes | the size asked for |
| `method` | `text` | yes | how the sample was drawn |



## Routes that use it
No route takes or returns PreviewSample directly. The record holds it, and the objects that point at it reach it.


---
title: "Price"
description: "the price of one kind of usage under one plan kind: per unit, its currency, and the quantity the plan includes"
section: concepts
address: /concepts/price
contract: 0476e35e6e275db5
---

# Price

the price of one kind of usage under one plan kind: per unit, its currency, and the quantity the plan includes

[figure: Price is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | operations |



## Fields


| field | type | required | note |
|---|---|---|---|
| `kind` | [KindOfUsage](/concepts/kindofusage) | yes |  |
| `plan_kind` | `one of trial \| paid \| internal` | yes |  |
| `per_unit` | `money` | yes |  |
| `included` | `count` | yes | in the kind's unit |



## Routes that use it
No route takes or returns Price directly. The record holds it, and the objects that point at it reach it.


---
title: "PriceLadder"
description: "the tenant's tiers in order with the study that set them; extends the price list, whose version in force the metering reads; a change is a new version"
section: concepts
address: /concepts/priceladder
contract: 0476e35e6e275db5
---

# PriceLadder

the tenant's tiers in order with the study that set them; extends the price list, whose version in force the metering reads; a change is a new version

[figure: PriceLadder is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | its version |
| store | postgres |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `version` | `count` | yes |  |
| `from` | `date` | yes | the date it is in force from |
| `tiers` | [PriceTier](/concepts/pricetier) | yes |  |
| `price_list` | `id` | yes | the price list version the tiers price their metered usage from |
| `study` | `id` | yes | the pricing study that set it |
| `state` | [Readiness](/concepts/readiness) | yes | not ready when a tier has no offering or no allowance, or the study is absent |



## Routes that use it
- [`/v1/economics/ladder`](/reference/economics/ladder) returns it


---
title: "PriceList"
description: "the prices in force from a date, versioned; a change is a new version"
section: concepts
address: /concepts/pricelist
contract: 0476e35e6e275db5
---

# PriceList

the prices in force from a date, versioned; a change is a new version

[figure: PriceList is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | its version |
| store | postgres |
| family | operations |



## Fields


| field | type | required | note |
|---|---|---|---|
| `version` | `count` | yes |  |
| `from` | `date` | yes |  |
| `prices` | [Price](/concepts/price) | yes |  |



## Routes that use it
No route takes or returns PriceList directly. The record holds it, and the objects that point at it reach it.


---
title: "PriceTier"
description: "one tier of the tenant's price ladder: its prices, its allowances, its offerings, who it is for, and where on the rivals' distribution it was set"
section: concepts
address: /concepts/pricetier
contract: 0476e35e6e275db5
---

# PriceTier

one tier of the tenant's price ladder: its prices, its allowances, its offerings, who it is for, and where on the rivals' distribution it was set

[figure: PriceTier is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | one tier of the ladder |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `order` | `count` | yes |  |
| `monthly` | `money` | yes |  |
| `annual` | `money` | yes | the price a month on an annual term |
| `currency` | `text` | yes |  |
| `allowances` | [Allowance](/concepts/allowance) | yes |  |
| `seats` | `count` | no | a parameter of the receive family |
| `markets` | `count` | no | a parameter of the receive family |
| `credits` | `count` | no | a parameter of the receive family |
| `offerings` | `[id]` | yes | the offerings the tier holds |
| `for_kinds` | `[id]` | no | the buyer profiles it is for |
| `quantile` | `share` | no | the position on the rivals' distribution the study set it at |



## Routes that use it
No route takes or returns PriceTier directly. The record holds it, and the objects that point at it reach it.


---
title: "PricingStudy"
description: "one run of the pricing methods over the frames of every buyer profile and the rivals' price claims of a window, with its candidates as a set of options, the decision and its reasons, and the margin check"
section: concepts
address: /concepts/pricingstudy
contract: 0476e35e6e275db5
---

# PricingStudy

one run of the pricing methods over the frames of every buyer profile and the rivals' price claims of a window, with its candidates as a set of options, the decision and its reasons, and the margin check

[figure: PricingStudy is a fact at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | platform |
| key | the ladder version it set |
| store | postgres |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `ladder_version` | `count` | yes |  |
| `methods` | [Method](/concepts/method) | yes | the methods of the library it ran, at their versions |
| `kinds_of_buyer` | `[id]` | yes |  |
| `window` | [Window](/concepts/window) | yes | the window of the rivals' claims read |
| `anchors` | `[id]` | yes | the rivals' price claims read |
| `frames` | `[id]` | yes | the frames of a sale read, by buyer profile |
| `candidates` | `id` | yes | the set of options document |
| `decision` | `text` | yes | the candidate decided, or none yet |
| `reasons` | `[text]` | yes |  |
| `margin` | [MarginCheck](/concepts/margincheck) | yes |  |
| `bar_set_before_reading` | `bool` | yes | false marks the study as not to be read |



## Routes that use it
- [`/v1/economics/study`](/reference/economics/study) returns it


---
title: "PricingStudyInput"
description: "the methods to run, the buyer profiles, and the window of the rivals' claims"
section: concepts
address: /concepts/pricingstudyinput
contract: 0476e35e6e275db5
---

# PricingStudyInput

the methods to run, the buyer profiles, and the window of the rivals' claims

[figure: PricingStudyInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | one ask of a study |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `methods` | [Method](/concepts/method) | yes |  |
| `kinds_of_buyer` | `[id]` | yes |  |
| `window` | [Window](/concepts/window) | yes |  |



## Routes that use it
- [`/v1/economics/study`](/reference/economics/study) takes it as input


---
title: "PrivateNetwork"
description: "the private network the machines share: its address range and the machines on it"
section: concepts
address: /concepts/privatenetwork
contract: 0476e35e6e275db5
---

# PrivateNetwork

the private network the machines share: its address range and the machines on it

[figure: PrivateNetwork is a definition at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | platform |
| key | its name |
| store | postgres |
| family | network |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `cidr` | `text` | yes | 10.60.0.0/24 on the three machines |
| `members` | [MachineAddress](/concepts/machineaddress) | yes |  |



## Routes that use it
No route takes or returns PrivateNetwork directly. The record holds it, and the objects that point at it reach it.


---
title: "ProbeIdentityInput"
description: "a held identity to probe"
section: concepts
address: /concepts/probeidentityinput
contract: 0476e35e6e275db5
---

# ProbeIdentityInput

a held identity to probe

[figure: ProbeIdentityInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `identity` | `id` | yes |  |



## Routes that use it
- [`/v1/act/probe_identity`](/reference/act/probe_identity) takes it as input


---
title: "ProcedureResult"
description: "what one run of a named procedure in the workbench left: the procedure, the run, the hashes of its code and its inputs, its outputs as measures, how it ended and how long it took"
section: concepts
address: /concepts/procedureresult
contract: 0476e35e6e275db5
---

# ProcedureResult

what one run of a named procedure in the workbench left: the procedure, the run, the hashes of its code and its inputs, its outputs as measures, how it ended and how long it took

[figure: ProcedureResult is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `procedure` | [NamedProcedure](/concepts/namedprocedure) | yes |  |
| `run` | `id` | yes |  |
| `code_hash` | `hash` | no | absent when the procedure carries no code, and then every output is never measured |
| `inputs_hash` | `hash` | yes |  |
| `outputs` | [Measure](/concepts/measure) | yes | one for each number the code left, its kind the name the procedure leaves it under |
| `ended` | `one of ended \| failed \| stopped` | yes |  |
| `elapsed_ms` | `count` | yes |  |



## Routes that use it
No route takes or returns ProcedureResult directly. The record holds it, and the objects that point at it reach it.


---
title: "Progress"
description: "steps done of steps in all, and what the task waits for"
section: concepts
address: /concepts/progress
contract: 0476e35e6e275db5
---

# Progress

steps done of steps in all, and what the task waits for

[figure: Progress is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `done` | `count` | yes |  |
| `of` | `count` | yes |  |
| `waits_for` | `text` | no |  |
| `bytes_moved` | `bytes` | no |  |
| `bytes_in_all` | `bytes` | no |  |



## Routes that use it
No route takes or returns Progress directly. The record holds it, and the objects that point at it reach it.


---
title: "Proof"
description: "one arm of the four run on a draft: what was planted and what the check read"
section: concepts
address: /concepts/proof
contract: 0476e35e6e275db5
---

# Proof

one arm of the four run on a draft: what was planted and what the check read

[figure: Proof is a work at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | work |
| scope | follows |
| key | the draft and the arm |
| store | postgres |
| family | studio |



## Fields


| field | type | required | note |
|---|---|---|---|
| `draft` | `id` | yes |  |
| `arm` | `one of the planted fault \| the known member \| the empty population \| the member placed where the enumerator does not look` | yes |  |
| `planted` | `text` | yes |  |
| `read` | `text` | no |  |



## Routes that use it
No route takes or returns Proof directly. The record holds it, and the objects that point at it reach it.


---
title: "Propensity"
description: "the propensity of one buyer to buy one offering: an estimate with its interval and its balance of evidence, and the causes as the evidence that moved it with their weights"
section: concepts
address: /concepts/propensity
contract: 0476e35e6e275db5
---

# Propensity

the propensity of one buyer to buy one offering: an estimate with its interval and its balance of evidence, and the causes as the evidence that moved it with their weights

[figure: Propensity is a fact at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | follows |
| key | the buyer, the offering and the two dates |
| store | postgres+lake |
| family | models |



## Fields


| field | type | required | note |
|---|---|---|---|
| `buyer` | `id` | yes |  |
| `offering` | `id` | yes |  |
| `estimate` | [Estimate](/concepts/estimate) | yes | never a point without its interval |
| `causes` | [EvidenceRef](/concepts/evidenceref) | yes | what moved it, with weights |
| `inputs` | `[text]` | yes | the stage, the motives, the means, the affinity, the constraints and the demand mode read |
| `as_of` | [TwoDates](/concepts/twodates) | yes |  |



## Routes that use it
No route takes or returns Propensity directly. The record holds it, and the objects that point at it reach it.


---
title: "PropensityAnswer"
description: "every eligible actor and every fitting content with its propensity, and the one the policy would choose on each face"
section: concepts
address: /concepts/propensityanswer
contract: 0476e35e6e275db5
---

# PropensityAnswer

every eligible actor and every fitting content with its propensity, and the one the policy would choose on each face

[figure: PropensityAnswer is a view at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `rows` | [PropensityToMove](/concepts/propensitytomove) | yes |  |
| `chosen_actor` | `id` | no |  |
| `chosen_content` | `id` | no |  |
| `not_eligible` | [Reason](/concepts/reason) | yes | each candidate refused, with the reason |



## Routes that use it
- [`/v1/read/propensity`](/reference/read/propensity) returns it


---
title: "PropensityInput"
description: "a lead, a move or a play, and which faces to read: actors, content or both"
section: concepts
address: /concepts/propensityinput
contract: 0476e35e6e275db5
---

# PropensityInput

a lead, a move or a play, and which faces to read: actors, content or both

[figure: PropensityInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `lead` | `id` | yes |  |
| `move` | `id` | no |  |
| `play` | `id` | no |  |
| `faces` | `[one of actor \| content]` | yes |  |



## Routes that use it
- [`/v1/read/propensity`](/reference/read/propensity) takes it as input


---
title: "PropensitySheet"
description: "one buyer's propensity across every offering at one time, with the offerings the profile does not bind as never measured"
section: concepts
address: /concepts/propensitysheet
contract: 0476e35e6e275db5
---

# PropensitySheet

one buyer's propensity across every offering at one time, with the offerings the profile does not bind as never measured

[figure: PropensitySheet is a view at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | none |
| key | none |
| store | none |
| family | models |



## Fields


| field | type | required | note |
|---|---|---|---|
| `buyer` | `id` | yes |  |
| `rows` | [Propensity](/concepts/propensity) | yes |  |
| `not_bound` | `[id]` | yes | offerings the profile does not bind, never measured |
| `as_of` | [TwoDates](/concepts/twodates) | yes |  |



## Routes that use it
No route takes or returns PropensitySheet directly. The record holds it, and the objects that point at it reach it.


---
title: "PropensityToMove"
description: "the chance that a lead moves up a rung within the window if this actor touches it or this content reaches it, with its interval and its basis; a hypothesis of the face propensity; distinct from a buyer's Propensity to buy an offering (14 §2.4), which is the lead's side of the same question"
section: concepts
address: /concepts/propensitytomove
contract: 0476e35e6e275db5
---

# PropensityToMove

the chance that a lead moves up a rung within the window if this actor touches it or this content reaches it, with its interval and its basis; a hypothesis of the face propensity; distinct from a buyer's Propensity to buy an offering (14 §2.4), which is the lead's side of the same question

[figure: PropensityToMove is a fact at strategy scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | strategy |
| key | the face, the subject, the lead and the move |
| store | postgres+lake |
| family | strategy |



## Fields


| field | type | required | note |
|---|---|---|---|
| `face` | `one of actor \| content` | yes |  |
| `subject` | `id` | yes | the actor or the content |
| `lead` | `id` | yes |  |
| `move` | `id` | no |  |
| `play` | `id` | no |  |
| `rung_aimed` | [Stage](/concepts/stage) | yes | the next rung above the lead's |
| `window` | `duration` | yes |  |
| `chance` | `chance` | yes |  |
| `interval` | [Interval](/concepts/interval) | yes |  |
| `similarity` | `share` | yes | the semantic comparison of the lead's observations with the subject's |
| `need` | `share` | yes | the share of the lead's stated pains and needs the subject has met before |
| `history` | `count` | yes | the outcomes the estimate pooled |
| `odds` | `chance` | no | the chance the policy gave this subject of being chosen |
| `chosen` | `bool` | yes |  |
| `policy` | [Policy](/concepts/policy) | yes |  |
| `hypothesis` | `id` | yes |  |
| `state` | [Readiness](/concepts/readiness) | yes | not ready with no interval when uncalibrated |
| `read_at` | `time` | yes |  |



## Routes that use it
No route takes or returns PropensityToMove directly. The record holds it, and the objects that point at it reach it.


---
title: "ProposedFact"
description: "what a hypothesis proposes, exactly one of: a connection, a claim, an identity decision, or a move with the item that did it"
section: concepts
address: /concepts/proposedfact
contract: 0476e35e6e275db5
---

# ProposedFact

what a hypothesis proposes, exactly one of: a connection, a claim, an identity decision, or a move with the item that did it

[figure: ProposedFact is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | kernel |



## Fields


| field | type | required | note |
|---|---|---|---|
| `connection` | [Connection](/concepts/connection) | no |  |
| `claim` | [Claim](/concepts/claim) | no |  |
| `identity` | [IdentityDecision](/concepts/identitydecision) | no | a mention resolved to an entity |
| `move` | `id` | no | the move a captured item carried out |
| `item` | `id` | no | the content item that did it |



## Routes that use it
No route takes or returns ProposedFact directly. The record holds it, and the objects that point at it reach it.


---
title: "ProposeMoveInput"
description: "a play and the catch, or the play's schedule"
section: concepts
address: /concepts/proposemoveinput
contract: 0476e35e6e275db5
---

# ProposeMoveInput

a play and the catch, or the play's schedule

[figure: ProposeMoveInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `play` | `id` | yes |  |
| `catch` | `id` | no |  |
| `strategy` | `id` | yes |  |



## Routes that use it
- [`/v1/act/propose_move`](/reference/act/propose_move) takes it as input


---
title: "ProposeTemplateInput"
description: "a sample page the person marked, from which the model proposes a template's fields with evidence spans for the person to confirm"
section: concepts
address: /concepts/proposetemplateinput
contract: 0476e35e6e275db5
---

# ProposeTemplateInput

a sample page the person marked, from which the model proposes a template's fields with evidence spans for the person to confirm

[figure: ProposeTemplateInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `address` | `text` | yes |  |
| `page_kind` | `one of listing \| detail \| feed \| table \| search results \| infinite scroll \| document \| API response` | yes |  |
| `marked` | `[text]` | yes | the values the person pointed at |
| `as_identity` | `id` | no |  |



## Routes that use it
- [`/v1/ask/propose_template`](/reference/ask/propose_template) takes it as input


---
title: "Proxy"
description: "an observable the record can read standing for a thing it cannot"
section: concepts
address: /concepts/proxy
contract: 0476e35e6e275db5
---

# Proxy

an observable the record can read standing for a thing it cannot

[figure: Proxy is a definition at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | follows |
| key | its name and version |
| store | postgres |
| family | rules_engine |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `facet_kind` | [FacetKind](/concepts/facetkind) | yes |  |
| `observable` | `text` | yes |  |
| `stands_for` | `text` | yes |  |
| `engine` | `one of membership \| utterance \| position` | yes |  |
| `rule` | [Predicate](/concepts/predicate) | yes |  |
| `scope` | [Scope](/concepts/scope) | yes |  |
| `verdict` | `one of measured \| inferred` | yes |  |
| `strength` | [ProxyStrength](/concepts/proxystrength) | no |  |
| `universal_controls` | [ControlResult](/concepts/controlresult) | yes | the room separation and the split-half persistence |
| `named_controls` | [ControlResult](/concepts/controlresult) | yes |  |
| `calibration` | [Calibration](/concepts/calibration) | no |  |
| `aggregate_only` | `bool` | yes | the flag at the write path |
| `rights` | [Rights](/concepts/rights) | yes |  |
| `state` | [Readiness](/concepts/readiness) | yes | not ready until its controls have run |
| `counterexample` | `text` | no | the case that looks like the referent and is not |
| `customer_decision` | `text` | no | the decision it serves |



## Routes that use it
- [`/v1/act/keep_proxy`](/reference/act/keep_proxy) returns it


---
title: "ProxyBasket"
description: "a named, versioned list of proxies with its scope, read together over a subject, a set or groups"
section: concepts
address: /concepts/proxybasket
contract: 0476e35e6e275db5
---

# ProxyBasket

a named, versioned list of proxies with its scope, read together over a subject, a set or groups

[figure: ProxyBasket is a definition at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | follows |
| key | its name and version |
| store | postgres |
| family | rules_engine |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `proxies` | `[id]` | yes | by version |
| `scope` | [Scope](/concepts/scope) | yes |  |
| `version` | `count` | yes |  |
| `compound_calibration` | [Calibration](/concepts/calibration) | no | the basket's proxies compounded, its own row |



## Routes that use it
- [`/v1/act/keep_basket`](/reference/act/keep_basket) returns it


---
title: "ProxyMembership"
description: "a subject's membership in a proxy over a period, as a fact with its evidence: the verdict, the scale of association, and the likelihood where a band is calibrated"
section: concepts
address: /concepts/proxymembership
contract: 0476e35e6e275db5
---

# ProxyMembership

a subject's membership in a proxy over a period, as a fact with its evidence: the verdict, the scale of association, and the likelihood where a band is calibrated

[figure: ProxyMembership is a fact at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | follows |
| key | the proxy, its version and the subject |
| store | lake:ready |
| family | record |



## Fields


| field | type | required | note |
|---|---|---|---|
| `proxy` | `id` | yes |  |
| `proxy_version` | `hash` | yes |  |
| `subject` | `id` | yes |  |
| `found_by` | `one of lexical \| behavioural \| semantic \| position \| utterance` | yes |  |
| `overlap` | `share` | no | the scale of association: the share of the subject's activity in the proxy's observable set, weighted by affinity where the proxy widens |
| `aggregate_only` | `bool` | yes |  |
| `verdict` | `one of holds \| does not hold \| not evaluable` | yes |  |
| `period` | [Window](/concepts/window) | no | a membership is a period, not a date |
| `likelihood` | [Interval](/concepts/interval) | no | from the calibration by band of association; never measured where the band has none |
| `evidence` | [EvidenceRef](/concepts/evidenceref) | yes | a membership with no evidence cannot be written |
| `strength` | [ProxyStrength](/concepts/proxystrength) | no | the proxy's strength at the time |
| `adult` | `bool` | yes | true when a room the subject used in the period is marked adult; left out of every read by default |
| `adult_share` | `share` | no | the share of the subject's rows in the period that were in rooms marked adult; absent when none was |



## Routes that use it
No route takes or returns ProxyMembership directly. The record holds it, and the objects that point at it reach it.


---
title: "ProxyPolicy"
description: "how one way routes: which pool kind, whether the exit sticks to the held identity, the country, and which failure classes rotate the exit"
section: concepts
address: /concepts/proxypolicy
contract: 0476e35e6e275db5
---

# ProxyPolicy

how one way routes: which pool kind, whether the exit sticks to the held identity, the country, and which failure classes rotate the exit

[figure: ProxyPolicy is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `pool_kind` | `one of none \| datacenter \| residential \| ISP \| mobile \| the person's machine` | yes |  |
| `sticky_to_identity` | `bool` | yes | a signed-in identity keeps one exit |
| `country` | `text` | no |  |
| `rotate_on` | `[text]` | yes | failure classes |



## Routes that use it
No route takes or returns ProxyPolicy directly. The record holds it, and the objects that point at it reach it.


---
title: "ProxyReading"
description: "its members as a population, with the raw count, the estimate corrected by the undercount, and the interval"
section: concepts
address: /concepts/proxyreading
contract: 0476e35e6e275db5
---

# ProxyReading

its members as a population, with the raw count, the estimate corrected by the undercount, and the interval

[figure: ProxyReading is a view at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `proxy` | [Proxy](/concepts/proxy) | yes |  |
| `raw` | `count` | yes |  |
| `corrected` | [Interval](/concepts/interval) | no |  |
| `population` | [PopulationStatement](/concepts/populationstatement) | yes |  |
| `members` | `[id]` | no | under the rights; never for aggregate-only |



## Routes that use it
- [`/v1/read/proxy`](/reference/read/proxy) returns it


---
title: "ProxyReadInput"
description: "a proxy, and the window"
section: concepts
address: /concepts/proxyreadinput
contract: 0476e35e6e275db5
---

# ProxyReadInput

a proxy, and the window

[figure: ProxyReadInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `proxy` | `id` | yes |  |
| `window` | [Window](/concepts/window) | no |  |



## Routes that use it
- [`/v1/read/proxy`](/reference/read/proxy) takes it as input


---
title: "ProxyStrength"
description: "the strength of a proxy, never one number"
section: concepts
address: /concepts/proxystrength
contract: 0476e35e6e275db5
---

# ProxyStrength

the strength of a proxy, never one number

[figure: ProxyStrength is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | rules_engine |



## Fields


| field | type | required | note |
|---|---|---|---|
| `precision` | `share` | no |  |
| `recall` | `share` | no |  |
| `coverage` | `share` | no |  |
| `not_evaluable` | `share` | no |  |



## Routes that use it
No route takes or returns ProxyStrength directly. The record holds it, and the objects that point at it reach it.


---
title: "Publishing"
description: "a document put at an address, a kind of action with reach"
section: concepts
address: /concepts/publishing
contract: 0476e35e6e275db5
---

# Publishing

a document put at an address, a kind of action with reach

[figure: Publishing is a work at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | work |
| scope | follows |
| key | the document's version and the address |
| store | postgres |
| family | documents |



## Fields


| field | type | required | note |
|---|---|---|---|
| `build` | `id` | yes |  |
| `address` | `address` | yes |  |
| `key` | `id` | no |  |
| `receipt` | [PublishingReceipt](/concepts/publishingreceipt) | no |  |
| `action` | `id` | yes |  |



## Routes that use it
- [`/v1/act/publish`](/reference/act/publish) returns it
- [`/v1/act/withdraw`](/reference/act/withdraw) returns it


---
title: "PublishingReceipt"
description: "the version, when, and the readings it carried"
section: concepts
address: /concepts/publishingreceipt
contract: 0476e35e6e275db5
---

# PublishingReceipt

the version, when, and the readings it carried

[figure: PublishingReceipt is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | documents |



## Fields


| field | type | required | note |
|---|---|---|---|
| `version` | `count` | yes |  |
| `at` | `time` | yes |  |
| `readings` | [ChippedNumber](/concepts/chippednumber) | yes |  |



## Routes that use it
No route takes or returns PublishingReceipt directly. The record holds it, and the objects that point at it reach it.


---
title: "PublishInput"
description: "a build and an address"
section: concepts
address: /concepts/publishinput
contract: 0476e35e6e275db5
---

# PublishInput

a build and an address

[figure: PublishInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `build` | `id` | yes |  |
| `address` | `address` | yes |  |
| `key` | `id` | no |  |



## Routes that use it
- [`/v1/act/publish`](/reference/act/publish) takes it as input


---
title: "PushMapping"
description: "a record attribute written to a source field"
section: concepts
address: /concepts/pushmapping
contract: 0476e35e6e275db5
---

# PushMapping

a record attribute written to a source field

[figure: PushMapping is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `attribute` | `text` | yes |  |
| `source_field` | `text` | yes |  |
| `reversible` | `bool` | yes | a field with no reverse is pull-only |



## Routes that use it
No route takes or returns PushMapping directly. The record holds it, and the objects that point at it reach it.


---
title: "RaiseNeedInput"
description: "a demand cell to raise"
section: concepts
address: /concepts/raiseneedinput
contract: 0476e35e6e275db5
---

# RaiseNeedInput

a demand cell to raise

[figure: RaiseNeedInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `source` | [Source](/concepts/source) | yes |  |
| `entities` | [Predicate](/concepts/predicate) | yes |  |
| `bucket` | [Window](/concepts/window) | yes |  |
| `fields` | `[text]` | yes |  |
| `value` | `share` | yes |  |



## Routes that use it
- [`/v1/act/raise_need`](/reference/act/raise_need) takes it as input


---
title: "RateBound"
description: "rate, politeness and cost as typed values with dimensions"
section: concepts
address: /concepts/ratebound
contract: 0476e35e6e275db5
---

# RateBound

rate, politeness and cost as typed values with dimensions

[figure: RateBound is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | registers |



## Fields


| field | type | required | note |
|---|---|---|---|
| `calls` | `count` | yes |  |
| `per` | `duration` | yes |  |
| `politeness_budget` | `count` | yes | the calls that the host may make on the way within each period of the rate (per), at most the rate's calls, so that the host decides when to read within it and never reads at the source's ceiling; 0 sets no bound beyond the rate itself. It is a parameter of the source family, counted in calls per unit of time and enforced at the call under the lease (07 §2.1; 18 §2.1 and its parameters table) |
| `cost_per_call` | `money` | no |  |
| `ceiling_measured` | `count` | no | the measured ceiling of the rate |



## Routes that use it
No route takes or returns RateBound directly. The record holds it, and the objects that point at it reach it.


---
title: "RateLimit"
description: "requests allowed per window for one token, and per client address for the sign-in routes; over it the answer is 429 with Retry-After"
section: concepts
address: /concepts/ratelimit
contract: 0476e35e6e275db5
---

# RateLimit

requests allowed per window for one token, and per client address for the sign-in routes; over it the answer is 429 with Retry-After

[figure: RateLimit is a parameter at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | parameter |
| scope | platform |
| key | the token or the client address |
| store | postgres |
| family | network |



## Fields


| field | type | required | note |
|---|---|---|---|
| `subject` | `one of token \| client-address` | yes |  |
| `requests` | `count` | yes |  |
| `window` | `duration` | yes |  |
| `burst` | `count` | no |  |



## Routes that use it
No route takes or returns RateLimit directly. The record holds it, and the objects that point at it reach it.


---
title: "Reader"
description: "the durable work that moves units out of a place"
section: concepts
address: /concepts/reader
contract: 0476e35e6e275db5
---

# Reader

the durable work that moves units out of a place

[figure: Reader is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | the place it reads |
| store | postgres |
| family | kernel |



## Fields


| field | type | required | note |
|---|---|---|---|
| `place` | [Place](/concepts/place) | yes |  |
| `key_rule` | `text` | yes | its key comes from the unit |
| `deadline` | `duration` | yes |  |
| `capacity` | `count` | yes | it draws on a capacity |
| `beat` | [Beat](/concepts/beat) | no |  |



## Routes that use it
No route takes or returns Reader directly. The record holds it, and the objects that point at it reach it.


---
title: "Readiness"
description: "ready, or visibly not ready with the plain reason; there is no third state"
section: concepts
address: /concepts/readiness
contract: 0476e35e6e275db5
---

# Readiness

ready, or visibly not ready with the plain reason; there is no third state

[figure: Readiness is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | kernel |



## Fields


| field | type | required | note |
|---|---|---|---|
| `ready` | `bool` | yes |  |
| `reason` | `text` | no | required when not ready |
| `since` | `time` | yes |  |
| `what_would_make_it_ready` | `text` | no |  |



## Routes that use it
- [`/v1/act/probe_identity`](/reference/act/probe_identity) returns it


---
title: "ReadingOffered"
description: "the estimator offered to a buyer profile in return for a contact: the model it evaluates, the drivers it asks in order, what is shown at once and after the contact, the consent it states, its page, its play and the rung a submission lands on"
section: concepts
address: /concepts/readingoffered
contract: 0476e35e6e275db5
---

# ReadingOffered

the estimator offered to a buyer profile in return for a contact: the model it evaluates, the drivers it asks in order, what is shown at once and after the contact, the consent it states, its page, its play and the rung a submission lands on

[figure: ReadingOffered is a definition at brand scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | brand |
| key | the buyer profile and its version |
| store | postgres |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `kind_of_buyer` | `id` | yes |  |
| `business_model` | `id` | yes |  |
| `asks` | [KindOfMeasure](/concepts/kindofmeasure) | yes | the drivers the buyer states, in order; no more than the parameter allows |
| `shown_at_once` | `[text]` | yes | the outputs shown before any contact |
| `shown_after_contact` | `[text]` | yes |  |
| `contact_asked` | [ContactKind](/concepts/contactkind) | yes |  |
| `consent_text` | `text` | yes |  |
| `document` | `id` | yes | the estimator page, a document |
| `way` | [WayOfGoingToMarket](/concepts/wayofgoingtomarket) | yes | the row a reading offered for a contact |
| `play` | `id` | no |  |
| `rung` | `text` | yes | the ladder rung a submission with a contact lands on |
| `version` | `count` | yes |  |
| `state` | [Readiness](/concepts/readiness) | yes |  |



## Routes that use it
- [`/v1/economics/offer`](/reference/economics/offer) returns it


---
title: "ReadingOfferedInput"
description: "the buyer profile, the model and the drivers to ask"
section: concepts
address: /concepts/readingofferedinput
contract: 0476e35e6e275db5
---

# ReadingOfferedInput

the buyer profile, the model and the drivers to ask

[figure: ReadingOfferedInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | one ask to offer a reading |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `kind_of_buyer` | `id` | yes |  |
| `business_model` | `id` | yes |  |
| `asks` | [KindOfMeasure](/concepts/kindofmeasure) | yes |  |



## Routes that use it
- [`/v1/economics/offer`](/reference/economics/offer) takes it as input


---
title: "ReadingOfMeasure"
description: "a measure read at a time; a score today and last week are two facts"
section: concepts
address: /concepts/readingofmeasure
contract: 0476e35e6e275db5
---

# ReadingOfMeasure

a measure read at a time; a score today and last week are two facts

[figure: ReadingOfMeasure is a fact at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | follows |
| key | the subject, the kind, its version and the time read |
| store | lake:ready |
| family | record |



## Fields


| field | type | required | note |
|---|---|---|---|
| `subject` | `id` | yes | a content item or an entity |
| `measure` | [Measure](/concepts/measure) | yes |  |
| `definition_version` | `count` | yes |  |
| `slice` | `{text:text}` | no | the dimension and its value for a cut reading; the dimension is one of the measure's slices |



## Routes that use it
No route takes or returns ReadingOfMeasure directly. The record holds it, and the objects that point at it reach it.


---
title: "ReadSourceInput"
description: "run one kind of reading of an installed connector from a cursor"
section: concepts
address: /concepts/readsourceinput
contract: 0476e35e6e275db5
---

# ReadSourceInput

run one kind of reading of an installed connector from a cursor

[figure: ReadSourceInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `installed_connector` | `id` | yes |  |
| `kind_of_reading` | `id` | yes |  |
| `cursor` | `text` | no |  |
| `credit_cells` | `[id]` | no |  |



## Routes that use it
- [`/v1/ask/read_source`](/reference/ask/read_source) takes it as input


---
title: "ReadSourcePage"
description: "one page of source objects, the next cursor and the cells credited"
section: concepts
address: /concepts/readsourcepage
contract: 0476e35e6e275db5
---

# ReadSourcePage

one page of source objects, the next cursor and the cells credited

[figure: ReadSourcePage is a view at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `objects` | `[json]` | yes | each the serialisation of the source object row's shape |
| `next_cursor` | `text` | no |  |
| `cells` | `[id]` | yes |  |
| `hops` | [HopStamp](/concepts/hopstamp) | yes |  |



## Routes that use it
- [`/v1/ask/read_source`](/reference/ask/read_source) returns it


---
title: "Reason"
description: "one link of a chain of reasons"
section: concepts
address: /concepts/reason
contract: 0476e35e6e275db5
---

# Reason

one link of a chain of reasons

[figure: Reason is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `unit` | [UnitRef](/concepts/unitref) | yes |  |
| `state` | [Readiness](/concepts/readiness) | yes |  |
| `because` | [UnitRef](/concepts/unitref) | no |  |



## Routes that use it
No route takes or returns Reason directly. The record holds it, and the objects that point at it reach it.


---
title: "RebuildRun"
description: "bronze replayed through refine and accept at one code version; ready only when every partition's hash equals the live run's"
section: concepts
address: /concepts/rebuildrun
contract: 0476e35e6e275db5
---

# RebuildRun

bronze replayed through refine and accept at one code version; ready only when every partition's hash equals the live run's

[figure: RebuildRun is a work at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | work |
| scope | follows |
| key | the source or plane and the code version |
| store | postgres |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `target` | `text` | yes | a source, a plane or the whole record |
| `code_version` | `text` | yes |  |
| `partitions_compared` | `count` | yes |  |
| `first_difference` | `text` | no |  |
| `state` | [Readiness](/concepts/readiness) | yes |  |



## Routes that use it
No route takes or returns RebuildRun directly. The record holds it, and the objects that point at it reach it.


---
title: "Receipt"
description: "when each role restarted and published ready, the readings the procedure took, and who cut the tag"
section: concepts
address: /concepts/receipt
contract: 0476e35e6e275db5
---

# Receipt

when each role restarted and published ready, the readings the procedure took, and who cut the tag

[figure: Receipt is a fact at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | platform |
| key | the release |
| store | postgres |
| family | releases |



## Fields


| field | type | required | note |
|---|---|---|---|
| `release` | `id` | yes |  |
| `roles_ready` | `{text:time}` | yes |  |
| `readings` | [ChippedNumber](/concepts/chippednumber) | yes |  |
| `cut_by` | [Caller](/concepts/caller) | yes |  |
| `change_to_receipt` | `duration` | yes |  |



## Routes that use it
No route takes or returns Receipt directly. The record holds it, and the objects that point at it reach it.


---
title: "Receipts"
description: "the receipts of exports and erasures"
section: concepts
address: /concepts/receipts
contract: 0476e35e6e275db5
---

# Receipts

the receipts of exports and erasures

[figure: Receipts is a view at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `exports` | [ExportReceipt](/concepts/exportreceipt) | yes |  |
| `erasures` | [ErasureReceipt](/concepts/erasurereceipt) | yes |  |



## Routes that use it
- [`/v1/read/receipts`](/reference/read/receipts) returns it


---
title: "ReceiptsInput"
description: "which receipts to read"
section: concepts
address: /concepts/receiptsinput
contract: 0476e35e6e275db5
---

# ReceiptsInput

which receipts to read

[figure: ReceiptsInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `kind` | `one of export \| erasure` | yes |  |



## Routes that use it
- [`/v1/read/receipts`](/reference/read/receipts) takes it as input


---
title: "Recipe"
description: "what a document reads: saved views, predicates, estimates and figures"
section: concepts
address: /concepts/recipe
contract: 0476e35e6e275db5
---

# Recipe

what a document reads: saved views, predicates, estimates and figures

[figure: Recipe is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | documents |



## Fields


| field | type | required | note |
|---|---|---|---|
| `saved_views` | `[id]` | yes |  |
| `predicates` | `[hash]` | yes |  |
| `estimates` | `[id]` | yes |  |
| `figures` | [Figure](/concepts/figure) | yes |  |
| `version` | `count` | yes |  |
| `sections` | [ReportSection](/concepts/reportsection) | no | for a report: its sections in order, each running a method |



## Routes that use it
No route takes or returns Recipe directly. The record holds it, and the objects that point at it reach it.


---
title: "RedactionRule"
description: "what never leaves the browser: a field, a header, an address key or a pattern in the body, applied before hashing"
section: concepts
address: /concepts/redactionrule
contract: 0476e35e6e275db5
---

# RedactionRule

what never leaves the browser: a field, a header, an address key or a pattern in the body, applied before hashing

[figure: RedactionRule is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | its name, and the person when it is the person's own |
| store | postgres |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `applies_to` | `one of field \| header \| address key \| body pattern` | yes |  |
| `pattern` | `text` | yes |  |
| `person` | `id` | no | set when the rule is the person's own |
| `source` | `one of the platform \| the connector \| the person` | yes |  |



## Routes that use it
No route takes or returns RedactionRule directly. The record holds it, and the objects that point at it reach it.


---
title: "ReferabilityCondition"
description: "one of the ten conditions that must hold before a professional puts a name behind a brand; every vertical pack writes its own instance with its own check"
section: concepts
address: /concepts/referabilitycondition
contract: 0476e35e6e275db5
---

# ReferabilityCondition

one of the ten conditions that must hold before a professional puts a name behind a brand; every vertical pack writes its own instance with its own check

[figure: ReferabilityCondition is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | its name |
| store | postgres |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `one of scope stated \| admission criteria \| named accountable \| escalation path \| evidence graded \| protocol \| report back \| before and after \| qualified staff \| no overclaim` | yes |  |
| `order` | `count` | yes |  |
| `general_form` | `text` | yes |  |



## Routes that use it
No route takes or returns ReferabilityCondition directly. The record holds it, and the objects that point at it reach it.


---
title: "ReferabilityStatus"
description: "one referability condition for one brand, with its status and its evidence"
section: concepts
address: /concepts/referabilitystatus
contract: 0476e35e6e275db5
---

# ReferabilityStatus

one referability condition for one brand, with its status and its evidence

[figure: ReferabilityStatus is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `condition` | [ReferabilityCondition](/concepts/referabilitycondition) | yes |  |
| `status` | `one of met \| partly \| not met \| not applicable` | yes |  |
| `check` | `text` | yes | the pack's own check |
| `evidence` | [EvidenceRef](/concepts/evidenceref) | yes |  |



## Routes that use it
No route takes or returns ReferabilityStatus directly. The record holds it, and the objects that point at it reach it.


---
title: "Refusal"
description: "the one typed shape of every not-allowed and every error"
section: concepts
address: /concepts/refusal
contract: 0476e35e6e275db5
---

# Refusal

the one typed shape of every not-allowed and every error

[figure: Refusal is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | kernel |



## Fields


| field | type | required | note |
|---|---|---|---|
| `what_happened` | `text` | yes | in plain words a customer could act on |
| `input` | `text` | no | which input it was about |
| `rule` | [Law](/concepts/law) | yes | the rule, and why it exists |
| `why` | `text` | yes |  |
| `way_out` | `text` | yes | the call or the route that fixes it |
| `shape_of_the_fix` | `json` | no |  |
| `retry_can_help` | `bool` | yes |  |



## Routes that use it
No route takes or returns Refusal directly. The record holds it, and the objects that point at it reach it.


---
title: "Register"
description: "a register: a named list of rows whose shape is fixed and which grows by a row"
section: concepts
address: /concepts/register
contract: 0476e35e6e275db5
---

# Register

a register: a named list of rows whose shape is fixed and which grows by a row

[figure: Register is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | its name |
| store | postgres |
| family | registers |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `row_type` | `text` | yes | the owning type of a row |
| `closed_or_rows` | `one of closed list in code \| rows` | yes | by the rule of §2.1 |
| `hash` | `hash` | yes | of its rows, served with every read |
| `version` | `count` | yes |  |
| `rows` | `[json]` | yes | the rows, each the serialization of the row type |



## Routes that use it
No route takes or returns Register directly. The record holds it, and the objects that point at it reach it.


---
title: "RegisterAnswer"
description: "its rows and the hash, or one row or nothing"
section: concepts
address: /concepts/registeranswer
contract: 0476e35e6e275db5
---

# RegisterAnswer

its rows and the hash, or one row or nothing

[figure: RegisterAnswer is a view at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `rows` | `[json]` | no |  |
| `hash` | `hash` | yes |  |
| `row` | `json` | no |  |



## Routes that use it
- [`/v1/read/register`](/reference/read/register) returns it
- [`/v1/read/registered`](/reference/read/registered) returns it


---
title: "RegisterInput"
description: "a register by name, or a name to check"
section: concepts
address: /concepts/registerinput
contract: 0476e35e6e275db5
---

# RegisterInput

a register by name, or a name to check

[figure: RegisterInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `register` | `text` | yes |  |
| `name` | `text` | no | is this name registered |



## Routes that use it
- [`/v1/read/register`](/reference/read/register) takes it as input
- [`/v1/read/registered`](/reference/read/registered) takes it as input


---
title: "Regulation"
description: "a rule of a market or a place, as a row of the register of regulations"
section: concepts
address: /concepts/regulation
contract: 0476e35e6e275db5
---

# Regulation

a rule of a market or a place, as a row of the register of regulations

[figure: Regulation is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | the market or the place and the rule |
| store | postgres |
| family | people |



## Fields


| field | type | required | note |
|---|---|---|---|
| `market_or_place` | `text` | yes |  |
| `rule` | `text` | yes | in a sentence |
| `makes_not_ready` | `one of a kind of action \| a play \| holding a person` | yes |  |
| `asks_consent_for` | `text` | no |  |
| `lawful_basis` | `text` | no | for holding a person |
| `kept_for` | `duration` | no |  |
| `check` | `text` | yes | the check that can fail |



## Routes that use it
No route takes or returns Regulation directly. The record holds it, and the objects that point at it reach it.


---
title: "Release"
description: "a versioned, tagged artefact reaching production, with its readings and its receipt"
section: concepts
address: /concepts/release
contract: 0476e35e6e275db5
---

# Release

a versioned, tagged artefact reaching production, with its readings and its receipt

[figure: Release is a work at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | work |
| scope | platform |
| key | the version |
| store | postgres |
| family | releases |



## Fields


| field | type | required | note |
|---|---|---|---|
| `version` | `text` | yes |  |
| `commit` | `hash` | yes |  |
| `artefact` | `id` | yes |  |
| `checks` | [ControlResult](/concepts/controlresult) | yes |  |
| `readings` | [ChippedNumber](/concepts/chippednumber) | yes |  |
| `receipt` | [Receipt](/concepts/receipt) | no |  |
| `cut_by` | [Caller](/concepts/caller) | yes |  |



## Routes that use it
No route takes or returns Release directly. The record holds it, and the objects that point at it reach it.


---
title: "ReleaseArtefact"
description: "one image for each repository, with its version and its hash"
section: concepts
address: /concepts/releaseartefact
contract: 0476e35e6e275db5
---

# ReleaseArtefact

one image for each repository, with its version and its hash

[figure: ReleaseArtefact is a fact at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | platform |
| key | the repository and the version |
| store | postgres |
| family | releases |



## Fields


| field | type | required | note |
|---|---|---|---|
| `repository` | `text` | yes |  |
| `version` | `text` | yes |  |
| `hash` | `hash` | yes |  |
| `roles` | `[text]` | yes |  |



## Routes that use it
No route takes or returns ReleaseArtefact directly. The record holds it, and the objects that point at it reach it.


---
title: "ReleaseStamp"
description: "which release a running binary is: the platform's semantic version, the commit it was built from with its time, whether the build had changes beyond the commit, and the contract it carries; every process reports it in its handshake, its --version, its first log line and the client name on every event it writes, so…"
section: concepts
address: /concepts/releasestamp
contract: 0476e35e6e275db5
---

# ReleaseStamp

which release a running binary is: the platform's semantic version, the commit it was built from with its time, whether the build had changes beyond the commit, and the contract it carries; every process reports it in its handshake, its --version, its first log line and the client name on every event it writes, so…

[figure: ReleaseStamp is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `version` | `text` | yes | the platform's semantic version, one number for every crate and every packaged surface, from the workspace's manifest |
| `commit` | `text` | yes | the commit's hash |
| `commit_time` | `count` | yes | the commit's time as seconds since 1970; the order between releases |
| `dirty` | `bool` | yes | true when the build had changes beyond the commit |
| `contract` | `hash` | yes | the register hash of the contract the binary carries |



## Routes that use it
No route takes or returns ReleaseStamp directly. The record holds it, and the objects that point at it reach it.


---
title: "RememberInput"
description: "a memory to keep, or one to forget"
section: concepts
address: /concepts/rememberinput
contract: 0476e35e6e275db5
---

# RememberInput

a memory to keep, or one to forget

[figure: RememberInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `memory` | [Memory](/concepts/memory) | no |  |
| `forget` | `id` | no |  |



## Routes that use it
- [`/v1/act/remember`](/reference/act/remember) takes it as input


---
title: "RemovalReceipt"
description: "one place a removal reached"
section: concepts
address: /concepts/removalreceipt
contract: 0476e35e6e275db5
---

# RemovalReceipt

one place a removal reached

[figure: RemovalReceipt is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | people |



## Fields


| field | type | required | note |
|---|---|---|---|
| `place` | `one of the gold layer \| quantized embeddings \| the served tables \| the working set \| full-precision embeddings \| the backups \| the app's cache` | yes |  |
| `count_before` | `count` | yes |  |
| `count_after` | `count` | yes |  |
| `at` | `time` | yes |  |



## Routes that use it
No route takes or returns RemovalReceipt directly. The record holds it, and the objects that point at it reach it.


---
title: "RemovalRequest"
description: "a person is to be removed; carried out only when every part reports that it is gone"
section: concepts
address: /concepts/removalrequest
contract: 0476e35e6e275db5
---

# RemovalRequest

a person is to be removed; carried out only when every part reports that it is gone

[figure: RemovalRequest is a work at tenant scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | work |
| scope | tenant |
| key | who asks and the person named |
| store | postgres |
| family | people |



## Fields


| field | type | required | note |
|---|---|---|---|
| `asked_by` | [Caller](/concepts/caller) | yes |  |
| `person` | `id` | yes |  |
| `proof` | `text` | yes |  |
| `reason` | `text` | yes |  |
| `places_reached` | [RemovalReceipt](/concepts/removalreceipt) | yes | the seven places a fact touches, each with a count before and a zero after |



## Routes that use it
No route takes or returns RemovalRequest directly. The record holds it, and the objects that point at it reach it.


---
title: "Rendering"
description: "a proof that a surface renders inside the real shell, arrived at from a sibling"
section: concepts
address: /concepts/rendering
contract: 0476e35e6e275db5
---

# Rendering

a proof that a surface renders inside the real shell, arrived at from a sibling

[figure: Rendering is a work at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | work |
| scope | platform |
| key | the surface, the width, the theme and the version |
| store | postgres |
| family | interfaces |



## Fields


| field | type | required | note |
|---|---|---|---|
| `surface` | [Surface](/concepts/surface) | yes |  |
| `width` | `count` | yes |  |
| `theme` | `one of light \| dark` | yes |  |
| `version` | `count` | yes |  |
| `image` | `text` | no |  |
| `landmark_before` | `count` | no |  |
| `landmark_after` | `count` | no |  |
| `arrived_from` | [Surface](/concepts/surface) | yes |  |



## Routes that use it
No route takes or returns Rendering directly. The record holds it, and the objects that point at it reach it.


---
title: "ReportSection"
description: "one section of a report's recipe: its heading, the method it runs, the words of its audience and its figure"
section: concepts
address: /concepts/reportsection
contract: 0476e35e6e275db5
---

# ReportSection

one section of a report's recipe: its heading, the method it runs, the words of its audience and its figure

[figure: ReportSection is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | documents |



## Fields


| field | type | required | note |
|---|---|---|---|
| `heading` | `text` | yes |  |
| `method` | `id` | yes | a method of the library |
| `words` | `text` | yes | the audience's register |
| `figure` | [Figure](/concepts/figure) | no |  |



## Routes that use it
No route takes or returns ReportSection directly. The record holds it, and the objects that point at it reach it.


---
title: "ResourceFilter"
description: "what a read may download and what it must not: resource types allowed and denied, size caps, address patterns, and whether to render"
section: concepts
address: /concepts/resourcefilter
contract: 0476e35e6e275db5
---

# ResourceFilter

what a read may download and what it must not: resource types allowed and denied, size caps, address patterns, and whether to render

[figure: ResourceFilter is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `allow_types` | `[one of document \| script \| stylesheet \| font \| image \| video \| audio \| media \| xhr \| websocket \| other]` | yes |  |
| `deny_types` | `[one of document \| script \| stylesheet \| font \| image \| video \| audio \| media \| xhr \| websocket \| other]` | yes | denied wins |
| `max_bytes_per_resource` | `count` | no |  |
| `max_bytes_total` | `count` | no |  |
| `allow_patterns` | `[text]` | yes | address patterns |
| `deny_patterns` | `[text]` | yes |  |
| `render` | `one of static \| auto \| rendered` | yes | static fetches the document alone; auto renders only when the static read looks thin, as CrawlKit's extractor does; rendered always uses the browser |



## Routes that use it
No route takes or returns ResourceFilter directly. The record holds it, and the objects that point at it reach it.


---
title: "RestoreDrill"
description: "a backup restored into a throwaway target, with the time it took and the count that must match"
section: concepts
address: /concepts/restoredrill
contract: 0476e35e6e275db5
---

# RestoreDrill

a backup restored into a throwaway target, with the time it took and the count that must match

[figure: RestoreDrill is a work at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | work |
| scope | platform |
| key | the backup and the beat |
| store | postgres |
| family | operations |



## Fields


| field | type | required | note |
|---|---|---|---|
| `backup` | `id` | yes |  |
| `took` | `duration` | yes |  |
| `count_expected` | `count` | yes |  |
| `count_read` | `count` | yes |  |
| `rows_hash_matched` | `bool` | yes |  |



## Routes that use it
No route takes or returns RestoreDrill directly. The record holds it, and the objects that point at it reach it.


---
title: "RetentionClass"
description: "how long a unit is kept, and whether it may be pruned behind the gold layer"
section: concepts
address: /concepts/retentionclass
contract: 0476e35e6e275db5
---

# RetentionClass

how long a unit is kept, and whether it may be pruned behind the gold layer

[figure: RetentionClass is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | its name |
| store | postgres |
| family | registers |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `keep_for` | `duration` | yes |  |
| `prunable_behind_lake` | `bool` | yes |  |
| `basis` | `text` | yes | the rights, the plan, or the platform's own |



## Routes that use it
No route takes or returns RetentionClass directly. The record holds it, and the objects that point at it reach it.


---
title: "Rights"
description: "what the source allows to be done with what was read"
section: concepts
address: /concepts/rights
contract: 0476e35e6e275db5
---

# Rights

what the source allows to be done with what was read

[figure: Rights is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | people |



## Fields


| field | type | required | note |
|---|---|---|---|
| `keep` | `bool` | yes |  |
| `show_to_a_tenant` | `bool` | yes |  |
| `quote` | `bool` | yes |  |
| `publish_again` | `bool` | yes |  |
| `train_a_model_on` | `bool` | yes |  |
| `put_in_a_prompt` | `bool` | yes |  |
| `let_leave_the_platform` | `bool` | yes |  |
| `tier` | `one of 1 \| 2 \| 3 \| not allowed \| unknown` | yes | the legality tier; unknown makes the source not ready |
| `may_reach_a_lead` | `bool` | yes |  |
| `may_reach_outreach` | `bool` | yes |  |
| `basis` | `text` | no | the clause, the determination and its date that set the tier |
| `consent_ground` | `text` | no |  |
| `terms_posture` | `text` | no | the posture of the source's terms towards this use |
| `retention` | `duration` | no |  |
| `erasure_path` | `text` | no |  |
| `personal_data` | `text` | no | the category of personal data the source holds |



## Routes that use it
No route takes or returns Rights directly. The record holds it, and the objects that point at it reach it.


---
title: "RivalMarking"
description: "a tenant's marking of a rival, with the evidence that made it one; never on the shared plane"
section: concepts
address: /concepts/rivalmarking
contract: 0476e35e6e275db5
---

# RivalMarking

a tenant's marking of a rival, with the evidence that made it one; never on the shared plane

[figure: RivalMarking is a fact at brand scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | brand |
| key | the brand and the rival |
| store | postgres |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `brand` | `id` | yes |  |
| `rival` | `id` | yes |  |
| `marked_by` | [Caller](/concepts/caller) | yes |  |
| `evidence` | [EvidenceRef](/concepts/evidenceref) | yes |  |
| `hypothesis` | `id` | yes |  |
| `standing` | `one of under test \| supported \| refuted \| not a rival` | yes |  |



## Routes that use it
- [`/v1/act/mark_rival`](/reference/act/mark_rival) returns it


---
title: "Role"
description: "a named set of grants; platform originals a tenant copies"
section: concepts
address: /concepts/role
contract: 0476e35e6e275db5
---

# Role

a named set of grants; platform originals a tenant copies

[figure: Role is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | its name and its owner |
| store | postgres |
| family | people |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `grants` | [Grant](/concepts/grant) | yes |  |
| `original` | `id` | no | where a copy came from |
| `plain_words` | `text` | yes | what the role lets a person do, shown where a role is given |
| `owner` | `id` | no | the tenant that copied the role; absent on a platform original, which every tenant has |



## Routes that use it
No route takes or returns Role directly. The record holds it, and the objects that point at it reach it.


---
title: "RoleAroundADecision"
description: "one register of the roles people and organisations play around a decision and a market; a role never makes a buyer"
section: concepts
address: /concepts/rolearoundadecision
contract: 0476e35e6e275db5
---

# RoleAroundADecision

one register of the roles people and organisations play around a decision and a market; a role never makes a buyer

[figure: RoleAroundADecision is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | its name |
| store | postgres |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `side` | `one of the decision \| the market \| influence \| the rules` | yes |  |
| `does` | `text` | yes |  |
| `hands_on` | `text` | yes |  |
| `held_as` | [KindOfConnection](/concepts/kindofconnection) | yes |  |
| `can_be_a_lead` | `one of no \| sometimes \| only when a buyer profile names the role` | yes |  |
| `recognised_by` | [Predicate](/concepts/predicate) | no | the title words and cues that suggest a person holds the role |



## Routes that use it
No route takes or returns RoleAroundADecision directly. The record holds it, and the objects that point at it reach it.


---
title: "RoleHeld"
description: "a role held on a tenant, a brand or a strategy"
section: concepts
address: /concepts/roleheld
contract: 0476e35e6e275db5
---

# RoleHeld

a role held on a tenant, a brand or a strategy

[figure: RoleHeld is a definition at tenant scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | tenant |
| key | the user, the role and where |
| store | postgres |
| family | people |



## Fields


| field | type | required | note |
|---|---|---|---|
| `user` | `id` | yes |  |
| `role` | [Role](/concepts/role) | yes |  |
| `held_on` | [Scope](/concepts/scope) | yes |  |



## Routes that use it
No route takes or returns RoleHeld directly. The record holds it, and the objects that point at it reach it.


---
title: "RolesInput"
description: "nothing, or one role"
section: concepts
address: /concepts/rolesinput
contract: 0476e35e6e275db5
---

# RolesInput

nothing, or one role

[figure: RolesInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `role` | `text` | no |  |



## Routes that use it
- [`/v1/read/roles`](/reference/read/roles) takes it as input


---
title: "Rollback"
description: "the previous artefact put back, with the readings after"
section: concepts
address: /concepts/rollback
contract: 0476e35e6e275db5
---

# Rollback

the previous artefact put back, with the readings after

[figure: Rollback is a work at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | work |
| scope | platform |
| key | the release |
| store | postgres |
| family | releases |



## Fields


| field | type | required | note |
|---|---|---|---|
| `release` | `id` | yes |  |
| `previous` | `id` | yes |  |
| `schema_allows` | `bool` | yes |  |
| `readings_after` | [ChippedNumber](/concepts/chippednumber) | yes |  |



## Routes that use it
No route takes or returns Rollback directly. The record holds it, and the objects that point at it reach it.


---
title: "Route"
description: "one ingress route: a host and path prefix forwarded to one listener, over TLS"
section: concepts
address: /concepts/route
contract: 0476e35e6e275db5
---

# Route

one ingress route: a host and path prefix forwarded to one listener, over TLS

[figure: Route is a definition at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | platform |
| key | the host and the path prefix |
| store | postgres |
| family | network |



## Fields


| field | type | required | note |
|---|---|---|---|
| `host` | `text` | yes |  |
| `path_prefix` | `text` | yes |  |
| `backend` | [Listener](/concepts/listener) | yes | only an api-gateway listener may be a backend |
| `tls` | [Certificate](/concepts/certificate) | yes |  |
| `keeps_open_streams_on_change` | `bool` | yes | a route change must not drop a long-lived stream |
| `rate_limit` | [RateLimit](/concepts/ratelimit) | no |  |



## Routes that use it
No route takes or returns Route directly. The record holds it, and the objects that point at it reach it.


---
title: "RouteDeclaration"
description: "one route of the register with the data it loads: the tools it calls, their inputs and the slot each answer fills, and its transition class"
section: concepts
address: /concepts/routedeclaration
contract: 0476e35e6e275db5
---

# RouteDeclaration

one route of the register with the data it loads: the tools it calls, their inputs and the slot each answer fills, and its transition class

[figure: RouteDeclaration is a definition at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | platform |
| key | its route |
| store | postgres |
| family | interfaces |



## Fields


| field | type | required | note |
|---|---|---|---|
| `route` | `text` | yes |  |
| `scope` | `one of user \| strategy \| brand \| tenant \| platform` | yes |  |
| `title` | `text` | yes |  |
| `slots` | `[text]` | yes |  |
| `loads` | [RouteLoad](/concepts/routeload) | yes |  |
| `transition` | `one of none \| swap \| slide \| fade` | yes | a class of the motion rules |



## Routes that use it
No route takes or returns RouteDeclaration directly. The record holds it, and the objects that point at it reach it.


---
title: "RouteLoad"
description: "one tool a route calls when it opens: the tool, its inputs from the route's params, and the slot its response card fills"
section: concepts
address: /concepts/routeload
contract: 0476e35e6e275db5
---

# RouteLoad

one tool a route calls when it opens: the tool, its inputs from the route's params, and the slot its response card fills

[figure: RouteLoad is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | interfaces |



## Fields


| field | type | required | note |
|---|---|---|---|
| `tool` | `text` | yes | a tool id of the register |
| `inputs` | `json` | yes | from the route's params and search parameters |
| `fills` | `text` | yes | a slot name |



## Routes that use it
No route takes or returns RouteLoad directly. The record holds it, and the objects that point at it reach it.


---
title: "Router"
description: "a person or a voice whose worth is who they send, with its own ladder and its value unit"
section: concepts
address: /concepts/router
contract: 0476e35e6e275db5
---

# Router

a person or a voice whose worth is who they send, with its own ladder and its value unit

[figure: Router is a definition at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | platform |
| key | its name |
| store | postgres |
| family | strategy |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `discipline` | `text` | yes |  |
| `ladder` | [Ladder](/concepts/ladder) | yes | never heard to recommends to peers |
| `value_unit` | `text` | yes | the flow carried over time |
| `proxies` | `[id]` | yes |  |
| `sends` | [LeadsTo](/concepts/leadsto) | no | the buyer profiles it sends, each with the rate |
| `motives` | [Motive](/concepts/motive) | no | why it would send, with evidence |
| `standing` | `text` | no |  |
| `referability` | [ReferabilityStatus](/concepts/referabilitystatus) | no | the ten conditions before a professional puts a name behind a brand, each with its status |
| `count` | [NumberInPosition](/concepts/numberinposition) | no | how many of this router exist, measured, estimated or stipulated |



## Routes that use it
No route takes or returns Router directly. The record holds it, and the objects that point at it reach it.


---
title: "RouteToBuyer"
description: "a route to a buyer that is not a community: a voice, a router, a source or a paid surface, with how much of the kind it reaches now"
section: concepts
address: /concepts/routetobuyer
contract: 0476e35e6e275db5
---

# RouteToBuyer

a route to a buyer that is not a community: a voice, a router, a source or a paid surface, with how much of the kind it reaches now

[figure: RouteToBuyer is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `route` | `id` | yes |  |
| `kind` | `one of a voice \| a router \| a source \| a paid surface \| an event` | yes | a community is found_in, never a route |
| `now` | [Summary](/concepts/summary) | no |  |



## Routes that use it
No route takes or returns RouteToBuyer directly. The record holds it, and the objects that point at it reach it.


---
title: "RoutingAnswer"
description: "the rule; for a preview, which leads it would have admitted and who would have had them"
section: concepts
address: /concepts/routinganswer
contract: 0476e35e6e275db5
---

# RoutingAnswer

the rule; for a preview, which leads it would have admitted and who would have had them

[figure: RoutingAnswer is a view at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `rule` | [RoutingRule](/concepts/routingrule) | yes |  |
| `would_admit` | [LeadAssignment](/concepts/leadassignment) | no |  |



## Routes that use it
- [`/v1/act/routing`](/reference/act/routing) returns it


---
title: "RoutingInput"
description: "a routing rule to write, preview or arm"
section: concepts
address: /concepts/routinginput
contract: 0476e35e6e275db5
---

# RoutingInput

a routing rule to write, preview or arm

[figure: RoutingInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `rule` | [RoutingRule](/concepts/routingrule) | yes |  |
| `do` | `one of write \| preview \| arm` | yes |  |



## Routes that use it
- [`/v1/act/routing`](/reference/act/routing) takes it as input


---
title: "RoutingRule"
description: "a predicate over leads with a person or a team attached; its dry run is the preview"
section: concepts
address: /concepts/routingrule
contract: 0476e35e6e275db5
---

# RoutingRule

a predicate over leads with a person or a team attached; its dry run is the preview

[figure: RoutingRule is a definition at brand scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | brand |
| key | its name and version |
| store | postgres |
| family | leads |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `predicate` | `hash` | yes |  |
| `to` | [GrantHolder](/concepts/grantholder) | yes | a user or a team |
| `armed` | `bool` | yes |  |



## Routes that use it
No route takes or returns RoutingRule directly. The record holds it, and the objects that point at it reach it.


---
title: "Run"
description: "one carrying out of a workflow; every step durable work keyed by the run, the step and its input"
section: concepts
address: /concepts/run
contract: 0476e35e6e275db5
---

# Run

one carrying out of a workflow; every step durable work keyed by the run, the step and its input

[figure: Run is a work at strategy scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | work |
| scope | strategy |
| key | the workflow's version with what started it |
| store | postgres |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `workflow` | `id` | yes |  |
| `workflow_version` | `count` | yes |  |
| `started_by` | `id` | yes |  |
| `steps` | [StepResult](/concepts/stepresult) | yes |  |
| `deadline` | `time` | yes |  |
| `budget` | [Cost](/concepts/cost) | yes |  |
| `waits_for` | `text` | no |  |
| `caller` | [Caller](/concepts/caller) | yes |  |



## Routes that use it
No route takes or returns Run directly. The record holds it, and the objects that point at it reach it.


---
title: "RunActionInput"
description: "an action to run"
section: concepts
address: /concepts/runactioninput
contract: 0476e35e6e275db5
---

# RunActionInput

an action to run

[figure: RunActionInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `action` | `id` | yes |  |



## Routes that use it
- [`/v1/act/run_action`](/reference/act/run_action) takes it as input


---
title: "Rung"
description: "one rung: a predicate with its own coverage, mapped to one of the seven stages"
section: concepts
address: /concepts/rung
contract: 0476e35e6e275db5
---

# Rung

one rung: a predicate with its own coverage, mapped to one of the seven stages

[figure: Rung is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | rules_engine |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `predicate` | `hash` | yes |  |
| `stage` | [Stage](/concepts/stage) | yes |  |
| `good_for` | `duration` | yes | how long evidence at this rung stays fresh |
| `rate_to_next` | [NumberInPosition](/concepts/numberinposition) | no | the share that reaches the rung above, measured, estimated or stipulated |



## Routes that use it
No route takes or returns Rung directly. The record holds it, and the objects that point at it reach it.


---
title: "RunningService"
description: "a service of the platform, with its life"
section: concepts
address: /concepts/runningservice
contract: 0476e35e6e275db5
---

# RunningService

a service of the platform, with its life

[figure: RunningService is a work at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | work |
| scope | platform |
| key | its role and version |
| store | postgres |
| family | operations |



## Fields


| field | type | required | note |
|---|---|---|---|
| `role` | `text` | yes |  |
| `version` | `text` | yes |  |
| `host` | `text` | yes |  |
| `ready_at` | `time` | no |  |



## Routes that use it
No route takes or returns RunningService directly. The record holds it, and the objects that point at it reach it.


---
title: "RunProcedureInput"
description: "a named procedure to follow, with its inputs"
section: concepts
address: /concepts/runprocedureinput
contract: 0476e35e6e275db5
---

# RunProcedureInput

a named procedure to follow, with its inputs

[figure: RunProcedureInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `procedure` | [NamedProcedure](/concepts/namedprocedure) | yes |  |
| `inputs` | `json` | no |  |



## Routes that use it
- [`/v1/work/run_procedure`](/reference/work/run_procedure) takes it as input


---
title: "RunRequest"
description: "a run to make on the work plane: the workflow, the caller, the envelope and what started it"
section: concepts
address: /concepts/runrequest
contract: 0476e35e6e275db5
---

# RunRequest

a run to make on the work plane: the workflow, the caller, the envelope and what started it

[figure: RunRequest is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `workflow` | [Workflow](/concepts/workflow) | yes |  |
| `caller` | [Caller](/concepts/caller) | yes |  |
| `envelope` | [CallEnvelope](/concepts/callenvelope) | yes |  |
| `trigger` | `text` | yes | a person's word, or a beat at its tick |
| `deadline` | `time` | yes |  |
| `budget` | [Cost](/concepts/cost) | yes |  |



## Routes that use it
No route takes or returns RunRequest directly. The record holds it, and the objects that point at it reach it.


---
title: "RuntimeContext"
description: "one of the extension's six runtime contexts: what it may do and what it never does"
section: concepts
address: /concepts/runtimecontext
contract: 0476e35e6e275db5
---

# RuntimeContext

one of the extension's six runtime contexts: what it may do and what it never does

[figure: RuntimeContext is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `one of the service worker \| the side panel \| the content script \| the page hook \| the offscreen document \| the options page` | yes |  |
| `may` | `[text]` | yes |  |
| `never` | `[text]` | yes |  |



## Routes that use it
No route takes or returns RuntimeContext directly. The record holds it, and the objects that point at it reach it.


---
title: "SaleFrame"
description: "the sale framed for one buyer: what the first sale costs them, the value and the return in their own numbers with their basis, the payback, the sensitivity, and the framing chosen with its evidence; computed once by the one evaluator from a business model, and read by the sale, the estimator page and the signal"
section: concepts
address: /concepts/saleframe
contract: 0476e35e6e275db5
---

# SaleFrame

the sale framed for one buyer: what the first sale costs them, the value and the return in their own numbers with their basis, the payback, the sensitivity, and the framing chosen with its evidence; computed once by the one evaluator from a business model, and read by the sale, the estimator page and the signal

[figure: SaleFrame is a fact at brand scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | brand |
| key | the buyer, the offering, the business model version and the inputs hash |
| store | postgres+lake |
| family | strategy |



## Fields


| field | type | required | note |
|---|---|---|---|
| `buyer` | [UnitRef](/concepts/unitref) | yes | the lead, the entity, the buyer profile, or the anonymous session of a public page |
| `offering` | `id` | no | the offering, absent when the frame is for the tenant's tier alone |
| `tier` | `text` | no | the tier of the price ladder priced, when the offering is the tenant's |
| `business_model` | `id` | no | the business model evaluated; absent for a frame written by hand before the economics of the market were specified |
| `model_version` | `count` | no |  |
| `inputs` | [FrameInput](/concepts/frameinput) | no | every input read, with where it came from and its basis |
| `inputs_hash` | `hash` | no | the repeat key with the buyer, the offering and the version |
| `period` | `duration` | no | the buyer's period the outputs are stated per |
| `first_sale_cost` | [NumberInPosition](/concepts/numberinposition) | yes | in the buyer's own numbers; in the estimate position it names the estimate with its interval |
| `potential_value` | [NumberInPosition](/concepts/numberinposition) | yes | the incremental value over the period |
| `return` | [Interval](/concepts/interval) | no | value less cost, derived by the named rule, with its interval |
| `payback` | `duration` | no | cost over value per period |
| `payback_interval` | [Interval](/concepts/interval) | no | the payback with its interval when a simulation ran |
| `sensitivity` | [Sensitivity](/concepts/sensitivity) | no | one per stated driver |
| `simulation` | `id` | no | the run that gave the intervals; absent for a point evaluation |
| `framing` | [KindOfFraming](/concepts/kindofframing) | yes |  |
| `set_aside` | [KindOfFraming](/concepts/kindofframing) | no | the framings considered and not chosen |
| `evidence` | [EvidenceRef](/concepts/evidenceref) | yes | the motives, means, affinity and constraints that chose the framing |
| `state` | [Readiness](/concepts/readiness) | no | not ready with the leaf named when an input is withheld |



## Routes that use it
- [`/v1/economics/estimate`](/reference/economics/estimate) returns it


---
title: "SampleStratum"
description: "one stratum of a preview's sample: how many matched in it and how many are shown"
section: concepts
address: /concepts/samplestratum
contract: 0476e35e6e275db5
---

# SampleStratum

one stratum of a preview's sample: how many matched in it and how many are shown

[figure: SampleStratum is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | rules_engine |



## Fields


| field | type | required | note |
|---|---|---|---|
| `stratum` | `text` | yes |  |
| `matched` | `count` | yes |  |
| `shown` | `count` | yes |  |



## Routes that use it
No route takes or returns SampleStratum directly. The record holds it, and the objects that point at it reach it.


---
title: "SampleUnit"
description: "one unit of a preview's sample, with the words that met the predicate"
section: concepts
address: /concepts/sampleunit
contract: 0476e35e6e275db5
---

# SampleUnit

one unit of a preview's sample, with the words that met the predicate

[figure: SampleUnit is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | rules_engine |



## Fields


| field | type | required | note |
|---|---|---|---|
| `unit` | `id` | yes |  |
| `kind` | `text` | yes |  |
| `name` | `text` | no |  |
| `stratum` | `text` | yes | the values of the population's strata, joined |
| `matched_by` | [Highlight](/concepts/highlight) | yes | the words of the unit that met each text condition |



## Routes that use it
No route takes or returns SampleUnit directly. The record holds it, and the objects that point at it reach it.


---
title: "SavedQuestion"
description: "a question over the view a person or the agent keeps"
section: concepts
address: /concepts/savedquestion
contract: 0476e35e6e275db5
---

# SavedQuestion

a question over the view a person or the agent keeps

[figure: SavedQuestion is a definition at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | follows |
| key | its name and scope |
| store | postgres |
| family | ops_console |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `over` | `one of stocks \| journeys \| waiting \| capabilities` | yes |  |
| `query` | `json` | yes |  |
| `scope` | [Scope](/concepts/scope) | yes |  |



## Routes that use it
- [`/v1/ask/keep_question`](/reference/ask/keep_question) returns it


---
title: "SavedView"
description: "a view over the record, a predicate or a recipe, kept current on a beat, served as a table"
section: concepts
address: /concepts/savedview
contract: 0476e35e6e275db5
---

# SavedView

a view over the record, a predicate or a recipe, kept current on a beat, served as a table

[figure: SavedView is a definition at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | follows |
| key | its name and version |
| store | postgres |
| family | rules_engine |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `source` | `one of a predicate \| a recipe` | yes |  |
| `predicate` | `hash` | no |  |
| `recipe` | `text` | no | a model's, a clustering's or a summary's |
| `columns` | [Column](/concepts/column) | yes |  |
| `beat` | [Beat](/concepts/beat) | yes |  |
| `built_ahead` | `bool` | yes |  |
| `population` | [PopulationStatement](/concepts/populationstatement) | no |  |
| `rights` | [Rights](/concepts/rights) | yes |  |



## Routes that use it
No route takes or returns SavedView directly. The record holds it, and the objects that point at it reach it.


---
title: "SavedViewAnswer"
description: "the definition, or its rows with when they were built"
section: concepts
address: /concepts/savedviewanswer
contract: 0476e35e6e275db5
---

# SavedViewAnswer

the definition, or its rows with when they were built

[figure: SavedViewAnswer is a view at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `view` | [SavedView](/concepts/savedview) | yes |  |
| `rows` | `[json]` | no | each the serialisation of the columns' types |
| `built_at` | `time` | no |  |



## Routes that use it
- [`/v1/ask/saved_view`](/reference/ask/saved_view) returns it


---
title: "SavedViewInput"
description: "a view to keep, or a view to read"
section: concepts
address: /concepts/savedviewinput
contract: 0476e35e6e275db5
---

# SavedViewInput

a view to keep, or a view to read

[figure: SavedViewInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `view` | [SavedView](/concepts/savedview) | no | to keep |
| `read` | `id` | no | to read its rows |
| `page` | `count` | no |  |



## Routes that use it
- [`/v1/ask/saved_view`](/reference/ask/saved_view) takes it as input


---
title: "Scope"
description: "one of the six scopes, each naming the ones above it"
section: concepts
address: /concepts/scope
contract: 0476e35e6e275db5
---

# Scope

one of the six scopes, each naming the ones above it

[figure: Scope is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | kernel |



## Fields


| field | type | required | note |
|---|---|---|---|
| `level` | `one of shared \| platform \| tenant \| brand \| strategy \| user` | yes |  |
| `tenant` | `id` | no | absent for shared and platform |
| `brand` | `id` | no |  |
| `strategy` | `id` | no |  |
| `user` | `id` | no |  |



## Routes that use it
No route takes or returns Scope directly. The record holds it, and the objects that point at it reach it.


---
title: "ScoreBySegment"
description: "the proper scores and the calibration of the forecasts of one segment: a play, a tactic, a kind of buyer, a framing, an actor or a content"
section: concepts
address: /concepts/scorebysegment
contract: 0476e35e6e275db5
---

# ScoreBySegment

the proper scores and the calibration of the forecasts of one segment: a play, a tactic, a kind of buyer, a framing, an actor or a content

[figure: ScoreBySegment is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `segment_kind` | `one of play \| tactic \| kind of buyer \| framing \| actor \| content` | yes |  |
| `segment` | `text` | yes |  |
| `pairs` | `count` | yes | the pairs with an effect |
| `mean_score` | `number` | no | the mean proper score; absent with no pair |
| `band_held` | `share` | no | the share of effects inside the band; absent with no pair |
| `level` | `share` | yes | the level the bands were stated at |
| `state` | [Readiness](/concepts/readiness) | yes | not ready when the band held under the level by more than the tolerance of interval coverage, or with fewer pairs than the floor |



## Routes that use it
No route takes or returns ScoreBySegment directly. The record holds it, and the objects that point at it reach it.


---
title: "ScoredUnit"
description: "a unit with its nearness"
section: concepts
address: /concepts/scoredunit
contract: 0476e35e6e275db5
---

# ScoredUnit

a unit with its nearness

[figure: ScoredUnit is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `unit` | [UnitRef](/concepts/unitref) | yes |  |
| `nearness` | `share` | yes |  |



## Routes that use it
No route takes or returns ScoredUnit directly. The record holds it, and the objects that point at it reach it.


---
title: "ScrapeRequest"
description: "arbitrary scraping as data: a scope, an extraction of fields or a schema for the model-assisted reader, the source object the rows become, a resource filter, a held identity and a proxy policy"
section: concepts
address: /concepts/scraperequest
contract: 0476e35e6e275db5
---

# ScrapeRequest

arbitrary scraping as data: a scope, an extraction of fields or a schema for the model-assisted reader, the source object the rows become, a resource filter, a held identity and a proxy policy

[figure: ScrapeRequest is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `template` | `id` | no | an extraction template; any of its parts may be overridden below |
| `scope` | [CrawlScope](/concepts/crawlscope) | no | required when no template |
| `fields` | [FieldSpec](/concepts/fieldspec) | no | declared selectors |
| `schema` | `json` | no | for the model-assisted reader, every value with its evidence span or refused |
| `source_object` | [SourceObject](/concepts/sourceobject) | yes | declared inline for one scrape, or a registered row |
| `mapping` | [Mapping](/concepts/mapping) | no |  |
| `filter` | [ResourceFilter](/concepts/resourcefilter) | yes |  |
| `as_identity` | `id` | no |  |
| `proxy_policy` | [ProxyPolicy](/concepts/proxypolicy) | no |  |
| `credit_cells` | `[id]` | no |  |
| `asked_by` | `text` | no | who asked for the run, as the caller's kind, or the crawler for an address a walk found; the beat takes what a person or the agent asked before the crawler's own discoveries, oldest first within each |



## Routes that use it
- [`/v1/ask/scrape`](/reference/ask/scrape) takes it as input
- [`/v1/act/crawl`](/reference/act/crawl) takes it as input


---
title: "ScrapeResult"
description: "the rows a scrape made, each a source object with its evidence span, the pages walked, what the filter denied, and the hops"
section: concepts
address: /concepts/scraperesult
contract: 0476e35e6e275db5
---

# ScrapeResult

the rows a scrape made, each a source object with its evidence span, the pages walked, what the filter denied, and the hops

[figure: ScrapeResult is a view at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | none |
| key | none |
| store | none |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `rows` | `[json]` | yes | each the serialisation of the declared source object |
| `evidence` | `[text]` | yes | the span each value was read from |
| `pages_walked` | `count` | yes |  |
| `pages_refused` | `count` | yes | by the rights row or the filter |
| `artefact_hashes` | `[hash]` | yes |  |
| `hops` | [HopStamp](/concepts/hopstamp) | yes |  |



## Routes that use it
- [`/v1/ask/scrape`](/reference/ask/scrape) returns it


---
title: "ScrapeRun"
description: "one run of an extraction template or of an inline scope: pages walked and denied, rows made, bytes, cost and time, with partial results at block boundaries; a whole site's crawl from its sitemap is one run"
section: concepts
address: /concepts/scraperun
contract: 0476e35e6e275db5
---

# ScrapeRun

one run of an extraction template or of an inline scope: pages walked and denied, rows made, bytes, cost and time, with partial results at block boundaries; a whole site's crawl from its sitemap is one run

[figure: ScrapeRun is a work at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | work |
| scope | follows |
| key | the template's version and the scope's hash |
| store | postgres |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `template` | `id` | yes |  |
| `template_version` | `count` | yes |  |
| `scope_hash` | `hash` | yes |  |
| `pages_walked` | `count` | yes |  |
| `pages_refused` | `count` | yes |  |
| `rows_made` | `count` | yes |  |
| `bytes` | `count` | yes |  |
| `cost` | [Cost](/concepts/cost) | yes |  |
| `failure` | [FailureClass](/concepts/failureclass) | no |  |
| `hops` | [HopStamp](/concepts/hopstamp) | yes |  |
| `request` | [ScrapeRequest](/concepts/scraperequest) | yes | the request the run carries out; the beat runs it from this field alone |
| `pages_found` | `count` | yes | the pages the sitemaps and the seeds gave the frontier |
| `gaps` | [CoverageGap](/concepts/coveragegap) | yes | one gap per page that could not be read, with its reason, and one for the pages past the budget |



## Routes that use it
- [`/v1/act/crawl`](/reference/act/crawl) returns it
- [`/v1/act/set_aside_run`](/reference/act/set_aside_run) returns it


---
title: "ScrapeRunsInput"
description: "the runs of a template in a window"
section: concepts
address: /concepts/scraperunsinput
contract: 0476e35e6e275db5
---

# ScrapeRunsInput

the runs of a template in a window

[figure: ScrapeRunsInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `template` | `id` | yes |  |
| `window` | [Window](/concepts/window) | yes |  |



## Routes that use it
- [`/v1/read/scrape_runs`](/reference/read/scrape_runs) takes it as input


---
title: "SculptedOffering"
description: "the offering as the search shaped it for one buyer profile: the value drivers it moves, the price position, the positioning against the rivals' claims, and the frame of a sale that priced it"
section: concepts
address: /concepts/sculptedoffering
contract: 0476e35e6e275db5
---

# SculptedOffering

the offering as the search shaped it for one buyer profile: the value drivers it moves, the price position, the positioning against the rivals' claims, and the frame of a sale that priced it

[figure: SculptedOffering is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `offering` | `id` | no | the existing offering, where the search starts from one |
| `concept` | `text` | yes | the offering in one sentence |
| `buyer_profile` | `id` | yes |  |
| `value_drivers_moved` | [KindOfMeasure](/concepts/kindofmeasure) | yes |  |
| `price_position` | [Interval](/concepts/interval) | no | where on the rivals' distribution it sits |
| `positioning` | `text` | yes |  |
| `against_rivals` | `[text]` | yes | each rival's claim this answers |
| `frame` | `id` | no | the sale frame that priced it |



## Routes that use it
No route takes or returns SculptedOffering directly. The record holds it, and the objects that point at it reach it.


---
title: "SearchRequest"
description: "one metasearch query through the self-hosted SearXNG, fanned out across engines"
section: concepts
address: /concepts/searchrequest
contract: 0476e35e6e275db5
---

# SearchRequest

one metasearch query through the self-hosted SearXNG, fanned out across engines

[figure: SearchRequest is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `query` | `text` | yes |  |
| `engines` | `[text]` | no | empty means the rows' default set |
| `categories` | `[text]` | no | general, news, science, social, code, images, videos, files, maps |
| `time_range` | [Window](/concepts/window) | no |  |
| `language` | `text` | no |  |
| `safe_search` | `one of off \| moderate \| strict` | yes |  |
| `count` | `count` | yes |  |
| `page` | `count` | yes |  |
| `as_identity` | `id` | no | a held identity, lent by a grant |
| `credit_cells` | `[id]` | no |  |



## Routes that use it
- [`/v1/ask/search`](/reference/ask/search) takes it as input


---
title: "SearchResult"
description: "one result of a metasearch, an observation with its source, its time basis and the engines that returned it"
section: concepts
address: /concepts/searchresult
contract: 0476e35e6e275db5
---

# SearchResult

one result of a metasearch, an observation with its source, its time basis and the engines that returned it

[figure: SearchResult is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `address` | `text` | yes | the canonical address after deduplication |
| `title` | `text` | yes |  |
| `snippet` | `text` | no |  |
| `engines` | `[text]` | yes |  |
| `rank` | `count` | yes |  |
| `published_at` | `time` | no |  |
| `basis_of_time` | `one of published \| scheduled \| first seen` | yes |  |
| `recognised` | `[id]` | yes | entities of the record recognised in the result |
| `artefact_hash` | `hash` | no | set once the page was read |



## Routes that use it
No route takes or returns SearchResult directly. The record holds it, and the objects that point at it reach it.


---
title: "SecretVersion"
description: "one version of a secret, with when and who"
section: concepts
address: /concepts/secretversion
contract: 0476e35e6e275db5
---

# SecretVersion

one version of a secret, with when and who

[figure: SecretVersion is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | people |



## Fields


| field | type | required | note |
|---|---|---|---|
| `version` | `count` | yes |  |
| `made_at` | `time` | yes |  |
| `rotated_by` | [Caller](/concepts/caller) | yes |  |
| `ends_at` | `time` | no |  |



## Routes that use it
No route takes or returns SecretVersion directly. The record holds it, and the objects that point at it reach it.


---
title: "SeedInput"
description: "the manifest to seed from, and the window in months"
section: concepts
address: /concepts/seedinput
contract: 0476e35e6e275db5
---

# SeedInput

the manifest to seed from, and the window in months

[figure: SeedInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `manifest` | `id` | yes |  |
| `window_months` | `count` | no | the parameter's value when empty |



## Routes that use it
- [`/v1/act/seed_tenant`](/reference/act/seed_tenant) takes it as input


---
title: "SeedManifest"
description: "what the seed of a tenant reads and what each file becomes: the files with their hashes, the corpus and the window, the mapping of each file to the objects it makes"
section: concepts
address: /concepts/seedmanifest
contract: 0476e35e6e275db5
---

# SeedManifest

what the seed of a tenant reads and what each file becomes: the files with their hashes, the corpus and the window, the mapping of each file to the objects it makes

[figure: SeedManifest is a definition at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | platform |
| key | the tenant and the version |
| store | postgres |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `tenant` | `id` | yes |  |
| `version` | `count` | yes |  |
| `files` | `[json]` | yes | path, hash, becomes |
| `corpus` | `text` | yes | the shared corpus it reads |
| `window_months` | `count` | yes | the parameter; one at first |
| `window_end` | `date` | yes | the corpus's most recent month |



## Routes that use it
No route takes or returns SeedManifest directly. The record holds it, and the objects that point at it reach it.


---
title: "SeedReceipt"
description: "what a seed wrote: the manifest's version, the window, the counts by kind, what was not ready with its reasons, and the hashes"
section: concepts
address: /concepts/seedreceipt
contract: 0476e35e6e275db5
---

# SeedReceipt

what a seed wrote: the manifest's version, the window, the counts by kind, what was not ready with its reasons, and the hashes

[figure: SeedReceipt is a fact at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | platform |
| key | the manifest and the time |
| store | postgres |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `manifest` | `id` | yes |  |
| `version` | `count` | yes |  |
| `window` | [Window](/concepts/window) | yes |  |
| `counts` | `json` | yes | by kind of object |
| `not_ready` | `[json]` | yes | object, reason |
| `hashes` | `[hash]` | yes |  |
| `ran_at` | `time` | yes |  |



## Routes that use it
- [`/v1/act/seed_tenant`](/reference/act/seed_tenant) returns it


---
title: "Segment"
description: "a buyer profile narrowed by a place, a size or a channel"
section: concepts
address: /concepts/segment
contract: 0476e35e6e275db5
---

# Segment

a buyer profile narrowed by a place, a size or a channel

[figure: Segment is a definition at brand scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | brand |
| key | the kind of buyer narrowed |
| store | postgres |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `kind_of_buyer` | `id` | yes |  |
| `place` | `id` | no |  |
| `size` | `text` | no |  |
| `channel` | `id` | no |  |



## Routes that use it
No route takes or returns Segment directly. The record holds it, and the objects that point at it reach it.


---
title: "SegmentOfAVertical"
description: "the slice of a vertical a brand sells to, with its template"
section: concepts
address: /concepts/segmentofavertical
contract: 0476e35e6e275db5
---

# SegmentOfAVertical

the slice of a vertical a brand sells to, with its template

[figure: SegmentOfAVertical is a definition at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | platform |
| key | the vertical and its name |
| store | postgres |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `vertical` | `id` | yes |  |
| `name` | `text` | yes |  |
| `what` | `text` | yes |  |
| `evidence_that_makes_an_account_relevant` | `text` | yes |  |
| `people_to_establish_separately` | `text` | yes |  |
| `help_before_a_sale` | `text` | yes |  |
| `template` | `id` | no |  |
| `offering_situation` | `text` | no | what is bought, in the segment's own words |
| `decision_problem` | `text` | no | the decision a buyer in it faces |
| `occupants` | `{text:text}` | no | keyed by a role of the register of roles: who holds each role around the decision in this segment, in words: the payer, the budget holder, the evaluator, the user, the referrer, the rule setter, the community, the supply actor |
| `chain_change` | `text` | no | what is changing in its chain |
| `proxies` | [Proxy](/concepts/proxy) | no | the proxies whose memberships make an account relevant to this segment; absent until bound |
| `eligible` | [Predicate](/concepts/predicate) | no | the population an account must be in before the proxies are read; absent until bound |



## Routes that use it
No route takes or returns SegmentOfAVertical directly. The record holds it, and the objects that point at it reach it.


---
title: "SemanticSearchAnswer"
description: "the units above the floor, with the model, the floor, the measured recall of quantized embeddings, and the tier"
section: concepts
address: /concepts/semanticsearchanswer
contract: 0476e35e6e275db5
---

# SemanticSearchAnswer

the units above the floor, with the model, the floor, the measured recall of quantized embeddings, and the tier

[figure: SemanticSearchAnswer is a view at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `units` | [ScoredUnit](/concepts/scoredunit) | yes |  |
| `model` | [Model](/concepts/model) | yes |  |
| `floor` | `share` | yes |  |
| `narrow_tier_recall` | `share` | yes |  |
| `tier` | `text` | yes |  |



## Routes that use it
- [`/v1/ask/semantic_search`](/reference/ask/semantic_search) returns it


---
title: "SemanticSearchInput"
description: "a text or a subject's vector, the model, a floor and a population"
section: concepts
address: /concepts/semanticsearchinput
contract: 0476e35e6e275db5
---

# SemanticSearchInput

a text or a subject's vector, the model, a floor and a population

[figure: SemanticSearchInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `text` | `text` | no |  |
| `subject` | [UnitRef](/concepts/unitref) | no |  |
| `model` | [Model](/concepts/model) | yes |  |
| `floor` | `share` | yes |  |
| `population` | [Predicate](/concepts/predicate) | yes |  |



## Routes that use it
- [`/v1/ask/semantic_search`](/reference/ask/semantic_search) takes it as input


---
title: "Sensitivity"
description: "the change in the return for a one-step change of one stated driver"
section: concepts
address: /concepts/sensitivity
contract: 0476e35e6e275db5
---

# Sensitivity

the change in the return for a one-step change of one stated driver

[figure: Sensitivity is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | one stated driver's effect on the return |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `driver` | [KindOfMeasure](/concepts/kindofmeasure) | yes |  |
| `step` | `json` | yes | the step, in the driver's dimension |
| `change_in_return` | [Interval](/concepts/interval) | yes |  |



## Routes that use it
No route takes or returns Sensitivity directly. The record holds it, and the objects that point at it reach it.


---
title: "ServerDescription"
description: "what the MCP server publishes: where the provider is, the proof method, the smallest scopes that work"
section: concepts
address: /concepts/serverdescription
contract: 0476e35e6e275db5
---

# ServerDescription

what the MCP server publishes: where the provider is, the proof method, the smallest scopes that work

[figure: ServerDescription is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | gateway |



## Fields


| field | type | required | note |
|---|---|---|---|
| `provider` | `address` | yes |  |
| `proof_method` | `text` | yes |  |
| `smallest_scopes` | [AccessScope](/concepts/accessscope) | yes |  |
| `families` | `[text]` | yes | the parts of the register, shown one at a time |
| `protocol_revision` | `date` | yes |  |



## Routes that use it
No route takes or returns ServerDescription directly. The record holds it, and the objects that point at it reach it.


---
title: "ServerInfo"
description: "what the app server returns in the handshake: its user agent, the protocol version, the contract hash and its capabilities"
section: concepts
address: /concepts/serverinfo
contract: 0476e35e6e275db5
---

# ServerInfo

what the app server returns in the handshake: its user agent, the protocol version, the contract hash and its capabilities

[figure: ServerInfo is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `user_agent` | `text` | yes | the platform's name and its version with the commit as build metadata, scale-intelligence/0.1.1+abc1234 |
| `protocol_version` | `text` | yes |  |
| `contract_hash` | `hash` | yes |  |
| `release` | [ReleaseStamp](/concepts/releasestamp) | yes | the release the server runs, so a client can show it and a report can name it |
| `capabilities` | `[text]` | yes |  |



## Routes that use it
No route takes or returns ServerInfo directly. The record holds it, and the objects that point at it reach it.


---
title: "ServiceNote"
description: "the short-lived signed token the API gateway hands the role behind it: who is calling, for which service, until when"
section: concepts
address: /concepts/servicenote
contract: 0476e35e6e275db5
---

# ServiceNote

the short-lived signed token the API gateway hands the role behind it: who is calling, for which service, until when

[figure: ServiceNote is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | network |



## Fields


| field | type | required | note |
|---|---|---|---|
| `caller` | [Caller](/concepts/caller) | yes |  |
| `audience` | `text` | yes | the one service it is made out to |
| `issued_at` | `time` | yes |  |
| `expires_at` | `time` | yes | seconds, never minutes |
| `signature` | `hash` | yes |  |



## Routes that use it
No route takes or returns ServiceNote directly. The record holds it, and the objects that point at it reach it.


---
title: "Session"
description: "one open sign-in of a user through a client"
section: concepts
address: /concepts/session
contract: 0476e35e6e275db5
---

# Session

one open sign-in of a user through a client

[figure: Session is a work at user scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | work |
| scope | user |
| key | the user, the client and when it began |
| store | postgres |
| family | people |



## Fields


| field | type | required | note |
|---|---|---|---|
| `user` | `id` | yes |  |
| `client` | `id` | yes |  |
| `began_at` | `time` | yes |  |
| `strength` | `one of password \| passkey \| second factor` | yes |  |
| `ends_at` | `time` | yes |  |
| `ended_by` | [Caller](/concepts/caller) | no |  |



## Routes that use it
No route takes or returns Session directly. The record holds it, and the objects that point at it reach it.


---
title: "SessionMaterial"
description: "the session material a signed-in identity of one platform holds and the read that proves it: the cookie domains the platform keeps, the address whose answer differs signed in from signed out, and the text that appears only when signed in"
section: concepts
address: /concepts/sessionmaterial
contract: 0476e35e6e275db5
---

# SessionMaterial

the session material a signed-in identity of one platform holds and the read that proves it: the cookie domains the platform keeps, the address whose answer differs signed in from signed out, and the text that appears only when signed in

[figure: SessionMaterial is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `cookie_domains` | `[text]` | yes | the cookie domains the identity keeps, without a leading dot |
| `probe_address` | `text` | yes | the address the cheapest signed-in read fetches |
| `signed_in_marker` | `text` | no | a text the probe's body carries only when signed in; absent when the status alone tells |
| `signed_in_cookie` | `text` | no | the name of the cookie whose presence on the platform's domain reads signed in while the person signs in inside the platform's window, so no read from outside the browser runs while the person types; absent when the probe alone tells |
| `pace` | [RateBound](/concepts/ratebound) | no | the pace a browsing session under this platform's identity reads at, which the way of a signed-in session carries as its rate bound; one call every twenty seconds when absent |
| `signed_out_statuses` | `[count]` | yes | the statuses the probe answers when signed out, redirects among them |
| `wall_patterns` | `[text]` | yes | the addresses of the platform's sign-in, sign-up, password and challenge pages; no request leaves for one of them, and a page that lands on one was not the page asked for, which under a held identity shows that the site signed the session out |
| `signed_out_markers` | `[text]` | yes | texts that a page's document carries only when the site shows the page signed out, such as LinkedIn's public tracking markers; a page read under a held identity that carries one shows that the site signed the session out |
| `private_patterns` | `[text]` | yes | the addresses of a signed-in person's own private pages (messages, notifications, their network, advertising accounts, settings); a walk that finds one never queues it, and no request leaves for one |
| `account_cookie` | `text` | no | the cookie whose value carries the id of the account that the session belongs to; absent when the probe's body carries it |
| `account_pattern` | `text` | no | a regular expression whose first group is the platform's own id of the account, read from the account cookie's value, or from the probe's body when no cookie is named; absent when the platform gives no way to read it |



## Routes that use it
No route takes or returns SessionMaterial directly. The record holds it, and the objects that point at it reach it.


---
title: "SessionState"
description: "the session state a held identity keeps in the store, checkpointed after each use: the cookies of the platform's cookie domains and when it was checkpointed"
section: concepts
address: /concepts/sessionstate
contract: 0476e35e6e275db5
---

# SessionState

the session state a held identity keeps in the store, checkpointed after each use: the cookies of the platform's cookie domains and when it was checkpointed

[figure: SessionState is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `platform` | `text` | yes |  |
| `cookies` | [HeldCookie](/concepts/heldcookie) | yes |  |
| `checkpointed_at` | `time` | yes |  |



## Routes that use it
No route takes or returns SessionState directly. The record holds it, and the objects that point at it reach it.


---
title: "SetAsideRunInput"
description: "a queued run to keep and never take up, with a person's plain reason"
section: concepts
address: /concepts/setasideruninput
contract: 0476e35e6e275db5
---

# SetAsideRunInput

a queued run to keep and never take up, with a person's plain reason

[figure: SetAsideRunInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `run` | `text` | yes | the run's key, as the runs read lists it |
| `reason` | `text` | yes | the plain reason the run waits, which its row and its event carry |



## Routes that use it
- [`/v1/act/set_aside_run`](/reference/act/set_aside_run) takes it as input


---
title: "SettingRow"
description: "one setting"
section: concepts
address: /concepts/settingrow
contract: 0476e35e6e275db5
---

# SettingRow

one setting

[figure: SettingRow is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | releases |



## Fields


| field | type | required | note |
|---|---|---|---|
| `role` | `text` | yes |  |
| `name` | `text` | yes |  |
| `dimension` | `text` | yes |  |
| `default` | `json` | yes |  |
| `changed_where` | `one of the console \| a release \| the environment at first` | yes |  |
| `parameter` | [Parameter](/concepts/parameter) | no |  |
| `values_by_place` | `json` | no | the value of this setting in each place where it differs from the default, keyed by the place's name (a developer's machine, the cluster); absent when one value serves every place; the cluster's render takes the cluster's value, so a row whose default names this machine's folders, executables or addresses carries one |



## Routes that use it
No route takes or returns SettingRow directly. The record holds it, and the objects that point at it reach it.


---
title: "SettingsDeclaration"
description: "every setting of every role, with its dimension, its default and where it may be changed"
section: concepts
address: /concepts/settingsdeclaration
contract: 0476e35e6e275db5
---

# SettingsDeclaration

every setting of every role, with its dimension, its default and where it may be changed

[figure: SettingsDeclaration is a definition at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | platform |
| key | the repository and the version |
| store | postgres |
| family | releases |



## Fields


| field | type | required | note |
|---|---|---|---|
| `settings` | [SettingRow](/concepts/settingrow) | yes |  |
| `version` | `text` | yes |  |



## Routes that use it
No route takes or returns SettingsDeclaration directly. The record holds it, and the objects that point at it reach it.


---
title: "SettleInput"
description: "a claim under test, settled"
section: concepts
address: /concepts/settleinput
contract: 0476e35e6e275db5
---

# SettleInput

a claim under test, settled

[figure: SettleInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `hypothesis` | `id` | yes |  |
| `standing` | `one of supported \| refuted \| cannot tell \| under test` | yes |  |
| `on` | `text` | yes | what it was settled on |



## Routes that use it
- [`/v1/act/settle`](/reference/act/settle) takes it as input


---
title: "SettleMatchAnswer"
description: "confirmed with the merge, or rejected"
section: concepts
address: /concepts/settlematchanswer
contract: 0476e35e6e275db5
---

# SettleMatchAnswer

confirmed with the merge, or rejected

[figure: SettleMatchAnswer is a view at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `match` | [PossibleMatch](/concepts/possiblematch) | yes |  |
| `merge` | [Merge](/concepts/merge) | no |  |



## Routes that use it
- [`/v1/act/settle_match`](/reference/act/settle_match) returns it


---
title: "SettleMatchInput"
description: "a possible match, confirmed or rejected"
section: concepts
address: /concepts/settlematchinput
contract: 0476e35e6e275db5
---

# SettleMatchInput

a possible match, confirmed or rejected

[figure: SettleMatchInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `match` | `id` | yes |  |
| `decision` | `one of confirm \| reject` | yes |  |
| `evidence` | [EvidenceRef](/concepts/evidenceref) | no |  |



## Routes that use it
- [`/v1/act/settle_match`](/reference/act/settle_match) takes it as input


---
title: "SharedRow"
description: "the one layout of a row of silver, in the refined layer"
section: concepts
address: /concepts/sharedrow
contract: 0476e35e6e275db5
---

# SharedRow

the one layout of a row of silver, in the refined layer

[figure: SharedRow is a fact at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | follows |
| key | the source, its own id and the version |
| store | lake:refined |
| family | registers |



## Fields


| field | type | required | note |
|---|---|---|---|
| `source` | [Source](/concepts/source) | yes |  |
| `source_object` | [SourceObject](/concepts/sourceobject) | yes |  |
| `own_id` | [IdWithSource](/concepts/idwithsource) | yes |  |
| `version` | `text` | yes |  |
| `times` | [TimeWithBasis](/concepts/timewithbasis) | yes | each with the basis of that time |
| `thread_root` | [IdWithSource](/concepts/idwithsource) | no |  |
| `parent` | [IdWithSource](/concepts/idwithsource) | no |  |
| `author_account` | [IdWithSource](/concepts/idwithsource) | no |  |
| `community` | [IdWithSource](/concepts/idwithsource) | no |  |
| `text` | `text` | no |  |
| `text_hash` | `hash` | no |  |
| `measures` | [Measure](/concepts/measure) | yes |  |
| `payload` | `json` | yes | only what the source object declares free-form; every declared field is a typed column of the source object's own silver table (SilverTable) |
| `plane` | [Plane](/concepts/plane) | yes |  |
| `ask` | `id` | yes | the ask it serves |
| `hops` | [HopStamp](/concepts/hopstamp) | yes | a stamp for each hop |



## Routes that use it
No route takes or returns SharedRow directly. The record holds it, and the objects that point at it reach it.


---
title: "Shell"
description: "the shell, drawn once: its slots, its parts, its three widths"
section: concepts
address: /concepts/shell
contract: 0476e35e6e275db5
---

# Shell

the shell, drawn once: its slots, its parts, its three widths

[figure: Shell is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | web or desktop |
| store | postgres |
| family | interfaces |



## Fields


| field | type | required | note |
|---|---|---|---|
| `kind` | `one of web \| desktop` | yes |  |
| `slots` | `[text]` | yes |  |
| `parts` | `[text]` | yes |  |
| `widths` | `[count]` | yes | 1440, 900, 390 |
| `version` | `count` | yes |  |



## Routes that use it
No route takes or returns Shell directly. The record holds it, and the objects that point at it reach it.


---
title: "Shortfall"
description: "one pass of the beat that fills the shortfall: every wanted cell read, a deepening asked for each entity its predicate names on the cell's source, the cell planned, covered once every deepening is fetched, or not satisfiable with the reason when the source needs a held identity the tenant does not hold"
section: concepts
address: /concepts/shortfall
contract: 0476e35e6e275db5
---

# Shortfall

one pass of the beat that fills the shortfall: every wanted cell read, a deepening asked for each entity its predicate names on the cell's source, the cell planned, covered once every deepening is fetched, or not satisfiable with the reason when the source needs a held identity the tenant does not hold

[figure: Shortfall is a work at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | work |
| scope | platform |
| key | the beat's tick |
| store | postgres |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `cells_read` | `count` | yes |  |
| `deepenings_asked` | `count` | yes | new work items; a deepening already asked or fetched counts as held |
| `cells_planned` | `count` | yes |  |
| `cells_covered` | `count` | yes |  |
| `cells_not_satisfiable` | `count` | yes |  |
| `at` | `time` | yes |  |



## Routes that use it
No route takes or returns Shortfall directly. The record holds it, and the objects that point at it reach it.


---
title: "Signal"
description: "a match with its kind, what it is about, its evidence and its rank for this brand"
section: concepts
address: /concepts/signal
contract: 0476e35e6e275db5
---

# Signal

a match with its kind, what it is about, its evidence and its rank for this brand

[figure: Signal is a fact at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | follows |
| key | the catch |
| store | postgres+lake |
| family | rules_engine |



## Fields


| field | type | required | note |
|---|---|---|---|
| `catch` | `id` | yes |  |
| `kind` | [KindOfSignal](/concepts/kindofsignal) | yes |  |
| `about` | [SignalSubject](/concepts/signalsubject) | yes |  |
| `evidence` | [EvidenceRef](/concepts/evidenceref) | yes | walkable to the sentence; a signal with no evidence cannot be written |
| `rank` | `count` | no |  |
| `confidence` | `share` | yes |  |
| `independent_sources` | `count` | yes |  |
| `brand` | `id` | no |  |



## Routes that use it
No route takes or returns Signal directly. The record holds it, and the objects that point at it reach it.


---
title: "SignalExport"
description: "one export of one signal kind from the collector to the store as Parquet"
section: concepts
address: /concepts/signalexport
contract: 0476e35e6e275db5
---

# SignalExport

one export of one signal kind from the collector to the store as Parquet

[figure: SignalExport is a work at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | work |
| scope | platform |
| key | the signal kind and the interval |
| store | postgres |
| family | observability |



## Fields


| field | type | required | note |
|---|---|---|---|
| `signal` | `one of traces \| logs \| metrics` | yes |  |
| `interval` | `duration` | yes |  |
| `files_written` | `[text]` | yes |  |
| `rows` | `count` | yes |  |
| `bytes` | `bytes` | yes |  |



## Routes that use it
No route takes or returns SignalExport directly. The record holds it, and the objects that point at it reach it.


---
title: "SignalsAnswer"
description: "the facts, with the coverage and the count not evaluable for the same window"
section: concepts
address: /concepts/signalsanswer
contract: 0476e35e6e275db5
---

# SignalsAnswer

the facts, with the coverage and the count not evaluable for the same window

[figure: SignalsAnswer is a view at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `signals` | [Signal](/concepts/signal) | yes |  |
| `catches` | [Catch](/concepts/catch) | no |  |
| `coverage` | [ChannelCoverage](/concepts/channelcoverage) | yes |  |
| `not_evaluable` | `count` | yes |  |



## Routes that use it
- [`/v1/read/signals`](/reference/read/signals) returns it


---
title: "SignalsInput"
description: "a monitor, a subject, a kind or a strategy, and a window"
section: concepts
address: /concepts/signalsinput
contract: 0476e35e6e275db5
---

# SignalsInput

a monitor, a subject, a kind or a strategy, and a window

[figure: SignalsInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `monitor` | `id` | no |  |
| `subject` | `id` | no |  |
| `kind` | [KindOfSignal](/concepts/kindofsignal) | no |  |
| `strategy` | `id` | no |  |
| `window` | [Window](/concepts/window) | yes |  |
| `catches` | `bool` | no | read catches instead |



## Routes that use it
- [`/v1/read/signals`](/reference/read/signals) takes it as input


---
title: "SignalStore"
description: "where signals land: object storage, one folder per signal kind and day, under a retention class per kind"
section: concepts
address: /concepts/signalstore
contract: 0476e35e6e275db5
---

# SignalStore

where signals land: object storage, one folder per signal kind and day, under a retention class per kind

[figure: SignalStore is a definition at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | platform |
| key | its address |
| store | postgres |
| family | observability |



## Fields


| field | type | required | note |
|---|---|---|---|
| `address` | `address` | yes |  |
| `layout` | `text` | yes | signals/{kind}/dt={day}/{export}.parquet |
| `retention` | `{text:row:RetentionClass}` | yes | keyed by the signal kind |
| `reader` | `text` | yes | DuckDB, from the ops console |



## Routes that use it
No route takes or returns SignalStore directly. The record holds it, and the objects that point at it reach it.


---
title: "SignalStrength"
description: "coverage, freshness at the tenth percentile, precision where truth is known, and independent corroboration"
section: concepts
address: /concepts/signalstrength
contract: 0476e35e6e275db5
---

# SignalStrength

coverage, freshness at the tenth percentile, precision where truth is known, and independent corroboration

[figure: SignalStrength is a view at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | none |
| key | read and never stored as one number |
| store | derived |
| family | rules_engine |



## Fields


| field | type | required | note |
|---|---|---|---|
| `coverage` | `share` | no |  |
| `freshness_p10` | `duration` | no |  |
| `precision` | `share` | no | where truth is known |
| `corroboration` | `count` | yes |  |
| `population` | [PopulationStatement](/concepts/populationstatement) | yes |  |



## Routes that use it
- [`/v1/read/monitor_strength`](/reference/read/monitor_strength) returns it


---
title: "SignalSubject"
description: "what a signal is about"
section: concepts
address: /concepts/signalsubject
contract: 0476e35e6e275db5
---

# SignalSubject

what a signal is about

[figure: SignalSubject is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | rules_engine |



## Fields


| field | type | required | note |
|---|---|---|---|
| `kind` | `one of an entity \| a market \| a channel \| a rival \| a tenant's own play` | yes |  |
| `id` | `id` | yes |  |



## Routes that use it
No route takes or returns SignalSubject directly. The record holds it, and the objects that point at it reach it.


---
title: "SignedInIdentity"
description: "an identity a person captured in a browser; the agent never types a password"
section: concepts
address: /concepts/signedinidentity
contract: 0476e35e6e275db5
---

# SignedInIdentity

an identity a person captured in a browser; the agent never types a password

[figure: SignedInIdentity is a definition at tenant scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | tenant |
| key | its id |
| store | postgres |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `platform` | `text` | yes |  |
| `label` | `text` | yes |  |
| `vault_entry` | `id` | yes | the store entry: made from the account when the session material reads one, so one account on one platform has one entry whatever it is called, and from the label otherwise |
| `account` | `text` | no | the platform's own id of the account that the session belongs to, read at the hold by the session material's account cookie or pattern; absent when the platform gives no way to read it |
| `names` | `[text]` | no | the other labels this account was held under, kept as names for it |
| `held_as` | `id` | no | the store entry that holds this account now, when a later hold of the same account replaced this entry; a run under this entry follows it there |
| `last_probe` | [ControlResult](/concepts/controlresult) | no |  |
| `state` | [Readiness](/concepts/readiness) | yes |  |



## Routes that use it
- [`/v1/act/hold_identity`](/reference/act/hold_identity) returns it


---
title: "SignInInput"
description: "nothing, or the tenant to sign in to; or an access token the identity provider issued, which a browser or an agent presents to the face it is connected on"
section: concepts
address: /concepts/signininput
contract: 0476e35e6e275db5
---

# SignInInput

nothing, or the tenant to sign in to; or an access token the identity provider issued, which a browser or an agent presents to the face it is connected on

[figure: SignInInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `tenant` | `id` | no |  |
| `token` | `text` | no | an access token the identity provider issued, checked six ways at the face; never logged |



## Routes that use it
- [`/v1/session/sign_in`](/reference/session/sign_in) takes it as input


---
title: "SignInProvider"
description: "who signs people in and issues tokens, registered by one address"
section: concepts
address: /concepts/signinprovider
contract: 0476e35e6e275db5
---

# SignInProvider

who signs people in and issues tokens, registered by one address

[figure: SignInProvider is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | its address |
| store | postgres |
| family | people |



## Fields


| field | type | required | note |
|---|---|---|---|
| `address` | `address` | yes |  |
| `description` | `json` | yes | read from what it publishes: its issuer identity, where its keys are, what it offers |
| `proof_method` | `text` | yes |  |
| `state` | [Readiness](/concepts/readiness) | yes | declined if the description cannot be fetched |
| `owner` | `one of the platform \| a tenant` | yes | a company's own directory is one more row |



## Routes that use it
No route takes or returns SignInProvider directly. The record holds it, and the objects that point at it reach it.


---
title: "SignOutInput"
description: "the session, or the user for every session"
section: concepts
address: /concepts/signoutinput
contract: 0476e35e6e275db5
---

# SignOutInput

the session, or the user for every session

[figure: SignOutInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `session` | `id` | no |  |
| `user` | `id` | no |  |



## Routes that use it
- [`/v1/session/sign_out`](/reference/session/sign_out) takes it as input


---
title: "SignUpInput"
description: "the company a person names on their first sign-in, so the platform makes their tenant on the trial plan"
section: concepts
address: /concepts/signupinput
contract: 0476e35e6e275db5
---

# SignUpInput

the company a person names on their first sign-in, so the platform makes their tenant on the trial plan

[figure: SignUpInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `company` | `text` | yes | the company's name as the person states it |
| `domain` | `text` | no | the company's website, which the map from a domain reads next |



## Routes that use it
- [`/v1/act/sign_up`](/reference/act/sign_up) takes it as input


---
title: "SilverTable"
description: "the silver table of one source object: the shared header, the source object's declared fields as typed columns, and the layout rule its key chooses"
section: concepts
address: /concepts/silvertable
contract: 0476e35e6e275db5
---

# SilverTable

the silver table of one source object: the shared header, the source object's declared fields as typed columns, and the layout rule its key chooses

[figure: SilverTable is a definition at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | platform |
| key | the source object and its version |
| store | postgres |
| family | registers |



## Fields


| field | type | required | note |
|---|---|---|---|
| `source_object` | [SourceObject](/concepts/sourceobject) | yes |  |
| `name` | `text` | yes | layer, source and object, one convention |
| `columns` | [Column](/concepts/column) | yes | the header's columns and then the declared fields, typed, each with its version |
| `layout` | `one of by day \| by entity bucket` | yes | chosen by the key, never by hand |
| `key_field` | `[text]` | yes | the ordered keys the layout follows; a table read from both ends declares both, and the writer keeps one copy under each |
| `version` | `count` | yes |  |
| `state` | [Readiness](/concepts/readiness) | yes | not ready when a declared field has no column |



## Routes that use it
No route takes or returns SilverTable directly. The record holds it, and the objects that point at it reach it.


---
title: "SimulationFrameInput"
description: "the simulation whose frame is read"
section: concepts
address: /concepts/simulationframeinput
contract: 0476e35e6e275db5
---

# SimulationFrameInput

the simulation whose frame is read

[figure: SimulationFrameInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `simulation` | `id` | yes |  |



## Routes that use it
- [`/v1/read/simulation_frame`](/reference/read/simulation_frame) takes it as input


---
title: "SimulationRun"
description: "the one evaluator run over sampled inputs to give a frame its intervals; deterministic under its seed; stops at its budget with the interval it reached"
section: concepts
address: /concepts/simulationrun
contract: 0476e35e6e275db5
---

# SimulationRun

the one evaluator run over sampled inputs to give a frame its intervals; deterministic under its seed; stops at its budget with the interval it reached

[figure: SimulationRun is a work at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | work |
| scope | platform |
| key | the model version, the inputs hash and the sample count |
| store | postgres |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `business_model` | `id` | yes |  |
| `model_version` | `count` | yes |  |
| `inputs_hash` | `hash` | yes |  |
| `samples` | `count` | yes |  |
| `seed` | `count` | yes |  |
| `level` | `share` | yes | the level of the intervals reported |
| `outputs` | `{text:json}` | no | each output as an Interval, by name |
| `elapsed_ms` | `count` | no |  |
| `reason` | `text` | no | why it stopped early or failed |



## Routes that use it
No route takes or returns SimulationRun directly. The record holds it, and the objects that point at it reach it.


---
title: "SiteBuild"
description: "one build of the documentation site, with the checks it ran; nothing is published from a failed build"
section: concepts
address: /concepts/sitebuild
contract: 0476e35e6e275db5
---

# SiteBuild

one build of the documentation site, with the checks it ran; nothing is published from a failed build

[figure: SiteBuild is a work at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | work |
| scope | platform |
| key | the version and the contract hash |
| store | postgres |
| family | documentation |



## Fields


| field | type | required | note |
|---|---|---|---|
| `version` | `text` | yes |  |
| `contract_hash` | `hash` | yes |  |
| `pages_built` | `count` | yes |  |
| `checks` | `[text]` | yes | each check's name, red on its planted control before the build counts it |



## Routes that use it
No route takes or returns SiteBuild directly. The record holds it, and the objects that point at it reach it.


---
title: "SiteWatch"
description: "a watched identity over a site: its page set and sitemap, its cadence through demand cells, the extraction applied to each page, the conditions that make a change a signal, and the channels told"
section: concepts
address: /concepts/sitewatch
contract: 0476e35e6e275db5
---

# SiteWatch

a watched identity over a site: its page set and sitemap, its cadence through demand cells, the extraction applied to each page, the conditions that make a change a signal, and the channels told

[figure: SiteWatch is a definition at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | follows |
| key | the site, on a brand or a tenant |
| store | postgres |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `site` | `id` | yes | the entity, a company or a brand, or an address |
| `page_patterns` | `[text]` | yes |  |
| `use_sitemap` | `bool` | yes | discovery and last-modified from the sitemap |
| `cadence` | `duration` | yes | arms cells |
| `extraction` | [FieldSpec](/concepts/fieldspec) | no | fields compared version to version |
| `conditions` | [Predicate](/concepts/predicate) | yes | over page changes |
| `channels` | `[id]` | yes | installed connectors with a send-to-channel action |
| `state` | [Readiness](/concepts/readiness) | yes |  |



## Routes that use it
- [`/v1/act/watch_site`](/reference/act/watch_site) returns it


---
title: "SizingPosition"
description: "a position a market is sized in, a register a person extends by a row: total, serviceable, signalling, customers, reachable, winnable, each with its definition"
section: concepts
address: /concepts/sizingposition
contract: 0476e35e6e275db5
---

# SizingPosition

a position a market is sized in, a register a person extends by a row: total, serviceable, signalling, customers, reachable, winnable, each with its definition

[figure: SizingPosition is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | its name |
| store | postgres |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `order` | `count` | yes |  |
| `definition` | `text` | yes | what the position counts |



## Routes that use it
No route takes or returns SizingPosition directly. The record holds it, and the objects that point at it reach it.


---
title: "Source"
description: "anywhere the market is read, with its rights and its role"
section: concepts
address: /concepts/source
contract: 0476e35e6e275db5
---

# Source

anywhere the market is read, with its rights and its role

[figure: Source is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | its name |
| store | postgres |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `market` | `text` | yes |  |
| `jurisdiction` | `text` | yes |  |
| `rights` | [Rights](/concepts/rights) | yes |  |
| `role` | `one of owns the record \| a copy of another platform's reading \| a one-off catch-up \| derived from other sources \| a tenant's own \| an extract with no chain of custody` | yes |  |
| `copy_of` | [Source](/concepts/source) | no |  |
| `legality_tier` | `one of 1 \| 2 \| 3 \| not allowed \| unknown` | yes | unknown makes the source not ready with the reason |
| `basis_of_times` | `one of published \| scheduled \| first seen \| captured \| imported \| retrieved` | yes | captured is when the source or an exporter took the reading, imported when it entered the system that held it, retrieved when it was fetched from that system |
| `state` | [Readiness](/concepts/readiness) | yes |  |
| `forced_open_by` | `text` | no | the law or rule that forces the source to publish, where one does; a register a regulator keeps names it |



## Routes that use it
No route takes or returns Source directly. The record holds it, and the objects that point at it reach it.


---
title: "SourceCatalogueEntry"
description: "one source in the catalogue with its connectors, kinds of reading and action, identity needed, rights tier, cost, state, coverage by cell and health"
section: concepts
address: /concepts/sourcecatalogueentry
contract: 0476e35e6e275db5
---

# SourceCatalogueEntry

one source in the catalogue with its connectors, kinds of reading and action, identity needed, rights tier, cost, state, coverage by cell and health

[figure: SourceCatalogueEntry is a view at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `source` | [Source](/concepts/source) | yes |  |
| `connectors` | [Connector](/concepts/connector) | yes |  |
| `readings` | [KindOfReading](/concepts/kindofreading) | yes |  |
| `actions` | [KindOfAction](/concepts/kindofaction) | yes |  |
| `installed` | [InstalledConnector](/concepts/installedconnector) | yes |  |
| `coverage` | [Coverage](/concepts/coverage) | yes |  |
| `health` | [Readiness](/concepts/readiness) | yes |  |



## Routes that use it
No route takes or returns SourceCatalogueEntry directly. The record holds it, and the objects that point at it reach it.


---
title: "SourceColumn"
description: "one column of a table of a read artefact, as the engine names it"
section: concepts
address: /concepts/sourcecolumn
contract: 0476e35e6e275db5
---

# SourceColumn

one column of a table of a read artefact, as the engine names it

[figure: SourceColumn is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `type` | `text` | yes | as the engine names it, such as VARCHAR or decimal128(2, 1) |
| `nullable` | `bool` | no | absent when the reading did not record it |



## Routes that use it
No route takes or returns SourceColumn directly. The record holds it, and the objects that point at it reach it.


---
title: "SourceField"
description: "a field of a source object"
section: concepts
address: /concepts/sourcefield
contract: 0476e35e6e275db5
---

# SourceField

a field of a source object

[figure: SourceField is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `type` | `one of text \| count \| number \| money \| share \| chance \| time \| date \| duration \| bool \| hash \| id \| json \| address \| bytes \| free-form` | yes | one of the register's primitives, or free-form for what lands in the payload |
| `required` | `bool` | yes |  |
| `code_system` | `text` | no | the registered code system a coded field's value belongs to, so a mapping resolves it to a code |
| `declared` | `text` | no | the source's own description of the field, in its words, when it has one |
| `path` | `text` | no | where in the artefact's record the field is read when it is not a key of the record: a key, a.b for a nested field, list[key=value].field for an item of a list of named pairs, or literal:<value> for a value the object declares itself |



## Routes that use it
No route takes or returns SourceField directly. The record holds it, and the objects that point at it reach it.


---
title: "SourceId"
description: "an id of a source object: its namespace, whether it is stable, the field that carries it and how far it is stable"
section: concepts
address: /concepts/sourceid
contract: 0476e35e6e275db5
---

# SourceId

an id of a source object: its namespace, whether it is stable, the field that carries it and how far it is stable

[figure: SourceId is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `namespace` | `text` | yes |  |
| `stable` | `bool` | yes |  |
| `field` | `text` | no | the field of the object that carries the id; an id with no field cannot be resolved, and a mapping that needs it is not ready |
| `stable_within` | `one of the source \| one export \| one file \| one session` | no | how far the id stays the same; absent until read |



## Routes that use it
No route takes or returns SourceId directly. The record holds it, and the objects that point at it reach it.


---
title: "SourceJoin"
description: "one join from a table of a read artefact to another source, by an identifier"
section: concepts
address: /concepts/sourcejoin
contract: 0476e35e6e275db5
---

# SourceJoin

one join from a table of a read artefact to another source, by an identifier

[figure: SourceJoin is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `left` | `text` | yes | the source, schema, table and column on this side |
| `right` | `text` | yes | the source, schema, table and column on the other side |
| `identifier_kind` | `text` | no | the kind of identifier the join is on, where the reading names it |
| `basis` | `text` | yes | how the join is known: inferred from the column names, stated by the generator, or measured |



## Routes that use it
No route takes or returns SourceJoin directly. The record holds it, and the objects that point at it reach it.


---
title: "SourceLink"
description: "a link between source objects"
section: concepts
address: /concepts/sourcelink
contract: 0476e35e6e275db5
---

# SourceLink

a link between source objects

[figure: SourceLink is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `to` | [SourceObject](/concepts/sourceobject) | yes |  |
| `self_asserted` | `bool` | yes |  |



## Routes that use it
No route takes or returns SourceLink directly. The record holds it, and the objects that point at it reach it.


---
title: "SourceObject"
description: "one kind of thing a source holds, in the source's own words"
section: concepts
address: /concepts/sourceobject
contract: 0476e35e6e275db5
---

# SourceObject

one kind of thing a source holds, in the source's own words

[figure: SourceObject is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | the source and its name |
| store | postgres |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `source` | [Source](/concepts/source) | yes |  |
| `name` | `text` | yes |  |
| `fields` | [SourceField](/concepts/sourcefield) | yes |  |
| `ids` | [SourceId](/concepts/sourceid) | yes |  |
| `times` | [SourceTime](/concepts/sourcetime) | yes |  |
| `measures` | [KindOfMeasure](/concepts/kindofmeasure) | yes |  |
| `links` | [SourceLink](/concepts/sourcelink) | yes |  |
| `plane` | [Plane](/concepts/plane) | no | absent for the platform's row; a tenant's extension row adds fields to a platform source object for that tenant only |
| `declared` | `text` | no | the source's own description of the object, in its words, when it has one |
| `header_fields` | `{text:text}` | no | which declared field fills each identity field of the shared silver header, by the header's own names: author_account, community, parent, thread_root, text; the refine of every way fills the header from this and never from a field chosen in code |



## Routes that use it
No route takes or returns SourceObject directly. The record holds it, and the objects that point at it reach it.


---
title: "SourceProcedure"
description: "how a source is read, derived from its row and its last reading: how it opens, every table with its count, population and control, the joins, the lineage and the pitfalls"
section: concepts
address: /concepts/sourceprocedure
contract: 0476e35e6e275db5
---

# SourceProcedure

how a source is read, derived from its row and its last reading: how it opens, every table with its count, population and control, the joins, the lineage and the pitfalls

[figure: SourceProcedure is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | the source and the reading |
| store | postgres |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `source` | `id` | yes |  |
| `kind` | `one of lake \| catalogue \| folder of files \| hypergraph \| embedding store \| predicate set \| derived table` | yes | one row for every kind |
| `path` | `text` | yes |  |
| `hash` | `hash` | yes | the file at the last reading |
| `generator` | `text` | yes | the program that made it, with its path and commit |
| `engine` | `text` | yes |  |
| `opens` | `text` | yes | the statement that attaches it read-only |
| `tables` | [SourceTable](/concepts/sourcetable) | yes | every table of the artefact with its count, population and control |
| `joins` | [SourceJoin](/concepts/sourcejoin) | yes | to other sources, by identifier |
| `pitfalls` | `[text]` | yes | each with the reading that showed it |
| `read_at` | `time` | yes |  |
| `stale` | `bool` | yes | past the parameter's age |
| `version` | `count` | yes |  |
| `state` | [Readiness](/concepts/readiness) | no | ready when the artefact opened and every table counted; not ready with the reason, such as a missing file or a table with no control; absent on a procedure not yet read |
| `bytes` | `bytes` | no | the size of the file, or of every file of the folder, at the reading; a changed size says the artefact was rebuilt without hashing it again |
| `modified` | `time` | no | when the file, or the newest file of the folder, was last changed, at the reading; a later time says the artefact was rebuilt without hashing it again |



## Routes that use it
- [`/v1/read/source_procedure`](/reference/read/source_procedure) returns it


---
title: "SourceProcedureInput"
description: "the source whose procedure to read"
section: concepts
address: /concepts/sourceprocedureinput
contract: 0476e35e6e275db5
---

# SourceProcedureInput

the source whose procedure to read

[figure: SourceProcedureInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `source` | `id` | yes |  |



## Routes that use it
- [`/v1/read/source_procedure`](/reference/read/source_procedure) takes it as input


---
title: "SourceRef"
description: "the source a fact came from, the way it was reached, and how it was fetched"
section: concepts
address: /concepts/sourceref
contract: 0476e35e6e275db5
---

# SourceRef

the source a fact came from, the way it was reached, and how it was fetched

[figure: SourceRef is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | record |



## Fields


| field | type | required | note |
|---|---|---|---|
| `source` | [Source](/concepts/source) | yes |  |
| `way` | [AccessMethod](/concepts/accessmethod) | yes |  |
| `job` | `id` | no |  |
| `hand_over` | `id` | no |  |



## Routes that use it
No route takes or returns SourceRef directly. The record holds it, and the objects that point at it reach it.


---
title: "SourceTable"
description: "one table of a read artefact: its count with its exactness, its population and the control that must come back right at the same hash"
section: concepts
address: /concepts/sourcetable
contract: 0476e35e6e275db5
---

# SourceTable

one table of a read artefact: its count with its exactness, its population and the control that must come back right at the same hash

[figure: SourceTable is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `schema` | `text` | yes |  |
| `table` | `text` | yes |  |
| `kind` | `one of table \| view \| file` | yes |  |
| `rows` | `count` | no | absent when the count was not read in the bound |
| `exactness` | `one of exact \| estimated \| not read in the bound` | yes |  |
| `columns` | [SourceColumn](/concepts/sourcecolumn) | no | absent when the reading did not list them |
| `population` | `text` | yes | what one row is |
| `control` | `text` | yes | the known count or row that must come back right at the same file hash: rows=<count>, bytes=<count>, or marker=<file>:<key> for a completion marker whose JSON names the count |
| `read_at` | `time` | yes |  |
| `files` | [LakeFile](/concepts/lakefile) | no | for a table that is a folder of files: each file with its hash, its bytes and its rows where read |
| `definition` | `text` | no | for a view of a catalogue: its definition as the engine states it, which is the rule that made the derived table; the files the definition reads are the table's files, and the rule is recorded on the procedure at every reading |



## Routes that use it
No route takes or returns SourceTable directly. The record holds it, and the objects that point at it reach it.


---
title: "SourceTime"
description: "a time of a source object, with what it means"
section: concepts
address: /concepts/sourcetime
contract: 0476e35e6e275db5
---

# SourceTime

a time of a source object, with what it means

[figure: SourceTime is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `field` | `text` | yes |  |
| `basis` | `one of published \| scheduled \| first seen \| captured \| imported \| retrieved` | yes | published, scheduled and first seen say when the thing happened; captured, imported and retrieved say when a reading of it was taken, and fill a fact's time with the basis read |



## Routes that use it
No route takes or returns SourceTime directly. The record holds it, and the objects that point at it reach it.


---
title: "Span"
description: "one timed operation inside a trace, with its attributes and its outcome"
section: concepts
address: /concepts/span
contract: 0476e35e6e275db5
---

# Span

one timed operation inside a trace, with its attributes and its outcome

[figure: Span is a fact at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | platform |
| key | its id |
| store | lake:landed |
| family | observability |



## Fields


| field | type | required | note |
|---|---|---|---|
| `span_id` | `hash` | yes |  |
| `context` | [TelemetryContext](/concepts/telemetrycontext) | yes |  |
| `name` | `text` | yes | the operation, from a closed list per role |
| `role` | `text` | yes |  |
| `started_at` | `time` | yes |  |
| `duration` | `duration` | yes |  |
| `outcome` | `one of ok \| refused \| failed \| timed-out` | yes |  |
| `attributes` | `{text:text}` | yes | from the attribute allow-list only; never a secret value |



## Routes that use it
No route takes or returns Span directly. The record holds it, and the objects that point at it reach it.


---
title: "SpeedBudget"
description: "the budget of one speed of the preview: units and time"
section: concepts
address: /concepts/speedbudget
contract: 0476e35e6e275db5
---

# SpeedBudget

the budget of one speed of the preview: units and time

[figure: SpeedBudget is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | rules_engine |



## Fields


| field | type | required | note |
|---|---|---|---|
| `units` | `count` | yes | the units the speed may read before it answers partial |
| `time_ms` | `count` | yes | the time it may take, in milliseconds |
| `sample` | `count` | no | the units a preview shows as its sample; twelve when absent |



## Routes that use it
No route takes or returns SpeedBudget directly. The record holds it, and the objects that point at it reach it.


---
title: "SpeedToLead"
description: "the delay from delivery to the first touch, read from two flows"
section: concepts
address: /concepts/speedtolead
contract: 0476e35e6e275db5
---

# SpeedToLead

the delay from delivery to the first touch, read from two flows

[figure: SpeedToLead is a definition at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | platform |
| key | its name |
| store | postgres |
| family | leads |



## Fields


| field | type | required | note |
|---|---|---|---|
| `target` | `duration` | no | held only where routing is set up |
| `readings` | [Measure](/concepts/measure) | yes |  |
| `population` | [PopulationStatement](/concepts/populationstatement) | yes |  |



## Routes that use it
- [`/v1/read/speed_to_lead`](/reference/read/speed_to_lead) returns it


---
title: "SpeedToLeadInput"
description: "a brand and a window"
section: concepts
address: /concepts/speedtoleadinput
contract: 0476e35e6e275db5
---

# SpeedToLeadInput

a brand and a window

[figure: SpeedToLeadInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `brand` | `id` | yes |  |
| `window` | [Window](/concepts/window) | yes |  |



## Routes that use it
- [`/v1/read/speed_to_lead`](/reference/read/speed_to_lead) takes it as input


---
title: "SqlAnswer"
description: "rows, with how many and whether a bound was reached"
section: concepts
address: /concepts/sqlanswer
contract: 0476e35e6e275db5
---

# SqlAnswer

rows, with how many and whether a bound was reached

[figure: SqlAnswer is a view at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `columns` | [Column](/concepts/column) | yes |  |
| `rows` | `[json]` | yes |  |
| `count` | `count` | yes |  |
| `bound_reached` | `bool` | yes |  |



## Routes that use it
- [`/v1/ask/sql`](/reference/ask/sql) returns it


---
title: "SqlBounds"
description: "the value of the parameter the bounds of a statement through the SQL path: rows returned, time and memory"
section: concepts
address: /concepts/sqlbounds
contract: 0476e35e6e275db5
---

# SqlBounds

the value of the parameter the bounds of a statement through the SQL path: rows returned, time and memory

[figure: SqlBounds is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | rules_engine |



## Fields


| field | type | required | note |
|---|---|---|---|
| `rows` | `count` | yes | rows returned |
| `time_ms` | `count` | yes |  |
| `memory_bytes` | `bytes` | yes |  |



## Routes that use it
No route takes or returns SqlBounds directly. The record holds it, and the objects that point at it reach it.


---
title: "SqlInput"
description: "a read-only query, in a strategy"
section: concepts
address: /concepts/sqlinput
contract: 0476e35e6e275db5
---

# SqlInput

a read-only query, in a strategy

[figure: SqlInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `query` | `text` | yes |  |
| `strategy` | `id` | yes |  |
| `bound` | `count` | no |  |



## Routes that use it
- [`/v1/ask/sql`](/reference/ask/sql) takes it as input


---
title: "Stage"
description: "one of the fixed stages every rung maps to, in a set, the seven buying stages or the router's seven, so ladders join across verticals within a set"
section: concepts
address: /concepts/stage
contract: 0476e35e6e275db5
---

# Stage

one of the fixed stages every rung maps to, in a set, the seven buying stages or the router's seven, so ladders join across verticals within a set

[figure: Stage is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | its name |
| store | postgres |
| family | rules_engine |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes | fixed rows per set: the seven buying stages from unaware to advocate; the router's seven from unheard to recommends to peers; the maturity stages of how far a company buys reach |
| `order` | `count` | yes |  |
| `set` | `one of buying \| routing \| maturity` | yes | a stage belongs to one set, and a rung maps to a stage of its ladder's set |



## Routes that use it
No route takes or returns Stage directly. The record holds it, and the objects that point at it reach it.


---
title: "StageState"
description: "one stage of the build as the view shows it"
section: concepts
address: /concepts/stagestate
contract: 0476e35e6e275db5
---

# StageState

one stage of the build as the view shows it

[figure: StageState is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | ops_console |



## Fields


| field | type | required | note |
|---|---|---|---|
| `stage` | `count` | yes |  |
| `procedure` | [NamedProcedure](/concepts/namedprocedure) | yes |  |
| `last_red` | `time` | no |  |
| `last_green` | `time` | no |  |
| `usable_by` | `date` | no |  |



## Routes that use it
No route takes or returns StageState directly. The record holds it, and the objects that point at it reach it.


---
title: "StatedNumber"
description: "one number a buyer stated about itself, within its driver's bounds, under the consent ground the surface stated; never edited, a later statement is a later fact"
section: concepts
address: /concepts/statednumber
contract: 0476e35e6e275db5
---

# StatedNumber

one number a buyer stated about itself, within its driver's bounds, under the consent ground the surface stated; never edited, a later statement is a later fact

[figure: StatedNumber is a fact at brand scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | brand |
| key | its subject, its driver and its time |
| store | postgres+lake |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `subject` | [UnitRef](/concepts/unitref) | yes | an entity, a lead, or an anonymous session on a public page |
| `driver` | [KindOfMeasure](/concepts/kindofmeasure) | yes |  |
| `value` | `json` | yes |  |
| `dimension` | `text` | yes |  |
| `stated_through` | `one of a page \| a call \| a form \| a capture` | yes |  |
| `consent_ground` | `text` | yes | the ground under which it is kept |
| `retention_class` | [RetentionClass](/concepts/retentionclass) | no | for a stranger's number: the class whose clock erases it |



## Routes that use it
No route takes or returns StatedNumber directly. The record holds it, and the objects that point at it reach it.


---
title: "StatusInput"
description: "watch, answer or stop a task"
section: concepts
address: /concepts/statusinput
contract: 0476e35e6e275db5
---

# StatusInput

watch, answer or stop a task

[figure: StatusInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `task` | `id` | yes |  |
| `do` | `one of watch \| answer \| stop` | yes |  |
| `answer` | [TaskQuestion](/concepts/taskquestion) | no |  |



## Routes that use it
- [`/v1/work/status`](/reference/work/status) takes it as input


---
title: "StepPage"
description: "the page after a browsing step that asked for a light reading: its address and its title, without a reading of the whole page"
section: concepts
address: /concepts/steppage
contract: 0476e35e6e275db5
---

# StepPage

the page after a browsing step that asked for a light reading: its address and its title, without a reading of the whole page

[figure: StepPage is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `address` | `text` | yes |  |
| `title` | `text` | yes |  |



## Routes that use it
No route takes or returns StepPage directly. The record holds it, and the objects that point at it reach it.


---
title: "StepResult"
description: "one step's result, kept so a second pass reads it back and never asks again"
section: concepts
address: /concepts/stepresult
contract: 0476e35e6e275db5
---

# StepResult

one step's result, kept so a second pass reads it back and never asks again

[figure: StepResult is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `step` | `count` | yes |  |
| `key` | `text` | yes |  |
| `outcome` | `one of done \| failed \| waiting \| skipped` | yes |  |
| `result` | `json` | no | a card, or a model's answer |
| `cost` | [Cost](/concepts/cost) | yes |  |
| `at` | `time` | yes |  |



## Routes that use it
No route takes or returns StepResult directly. The record holds it, and the objects that point at it reach it.


---
title: "Stock"
description: "for one kind, one place and one scope: the level, the rates, the age of the oldest with its reason, the count past the longest wait, and who reads it"
section: concepts
address: /concepts/stock
contract: 0476e35e6e275db5
---

# Stock

for one kind, one place and one scope: the level, the rates, the age of the oldest with its reason, the count past the longest wait, and who reads it

[figure: Stock is a view at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | platform |
| key | the kind, the place and the scope |
| store | derived |
| family | ops_console |



## Fields


| field | type | required | note |
|---|---|---|---|
| `kind` | [Kind](/concepts/kind) | yes |  |
| `place` | `text` | yes |  |
| `scope` | [Scope](/concepts/scope) | yes |  |
| `level` | `count` | no | no level when never read |
| `rate_in` | `count` | no |  |
| `rate_out` | `count` | no |  |
| `oldest` | [Oldest](/concepts/oldest) | no |  |
| `past_longest_wait` | `count` | no |  |
| `reader` | `text` | yes |  |
| `read_at` | `time` | no |  |



## Routes that use it
No route takes or returns Stock directly. The record holds it, and the objects that point at it reach it.


---
title: "StockLevel"
description: "one stock's level at one moment, in one of three positions"
section: concepts
address: /concepts/stocklevel
contract: 0476e35e6e275db5
---

# StockLevel

one stock's level at one moment, in one of three positions

[figure: StockLevel is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `stock` | `text` | yes |  |
| `unit` | `text` | yes |  |
| `level` | [Summary](/concepts/summary) | yes |  |
| `as_of` | `time` | yes |  |



## Routes that use it
No route takes or returns StockLevel directly. The record holds it, and the objects that point at it reach it.


---
title: "StocksInput"
description: "a scope, and optionally one kind"
section: concepts
address: /concepts/stocksinput
contract: 0476e35e6e275db5
---

# StocksInput

a scope, and optionally one kind

[figure: StocksInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `scope` | [Scope](/concepts/scope) | yes |  |
| `kind` | [Kind](/concepts/kind) | no |  |



## Routes that use it
- [`/v1/view/stocks`](/reference/view/stocks) takes it as input


---
title: "StockTrajectory"
description: "one stock's level at every step of a simulation, each an interval at the stated level"
section: concepts
address: /concepts/stocktrajectory
contract: 0476e35e6e275db5
---

# StockTrajectory

one stock's level at every step of a simulation, each an interval at the stated level

[figure: StockTrajectory is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `stock` | `text` | yes |  |
| `unit` | `text` | yes |  |
| `levels` | [Interval](/concepts/interval) | yes | one per step |



## Routes that use it
No route takes or returns StockTrajectory directly. The record holds it, and the objects that point at it reach it.


---
title: "Strategy"
description: "a strategy under a brand, or under several that share an owning company"
section: concepts
address: /concepts/strategy
contract: 0476e35e6e275db5
---

# Strategy

a strategy under a brand, or under several that share an owning company

[figure: Strategy is a definition at strategy scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | strategy |
| key | its id |
| store | postgres |
| family | strategy |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `brands` | `[id]` | yes |  |
| `goals` | `[id]` | yes |  |
| `plays` | `[id]` | yes |  |
| `monitors` | `[id]` | yes |  |
| `moves` | `[id]` | yes |  |
| `budget` | [Budget](/concepts/budget) | yes |  |
| `people` | [RoleHeld](/concepts/roleheld) | yes |  |
| `grants` | `[id]` | yes |  |
| `memory` | `[id]` | yes |  |
| `tasks` | `[id]` | yes |  |
| `window` | [Window](/concepts/window) | yes |  |
| `standing` | `bool` | yes | the brand's standing strategy |
| `life` | `one of drafted \| simulated \| rolled out in part \| running \| paused \| ended` | yes | the strategy's place in its life, moved only by the rules of the model's section 10.2; the standing strategy is born running |
| `version` | `count` | yes | a change to the graph while it runs is a new version; running moves finish under the version that proposed them |
| `game` | [Game](/concepts/game) | yes | the game it plays, read from the brand's way of going to market and its vertical when drafted |
| `graph` | [GraphEdge](/concepts/graphedge) | yes | the edges between its plays; a play with no edge into it starts on its own trigger |
| `simulations` | `[id]` | yes | every simulation it was laid on the twin for, the last one the frame N-13 shows |
| `origin` | `id` | no | the ended strategy this one started from |
| `policy` | [Policy](/concepts/policy) | yes | the policy that chooses among its ready arms |



## Routes that use it
- [`/v1/read/strategy`](/reference/read/strategy) returns it
- [`/v1/act/move_strategy`](/reference/act/move_strategy) returns it
- [`/v1/act/strategy`](/reference/act/strategy) returns it


---
title: "StrategyInput"
description: "a strategy to make"
section: concepts
address: /concepts/strategyinput
contract: 0476e35e6e275db5
---

# StrategyInput

a strategy to make

[figure: StrategyInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `strategy` | [Strategy](/concepts/strategy) | yes |  |



## Routes that use it
- [`/v1/act/strategy`](/reference/act/strategy) takes it as input


---
title: "StrategyMoveInput"
description: "a strategy moved to a place in its life, with the reason"
section: concepts
address: /concepts/strategymoveinput
contract: 0476e35e6e275db5
---

# StrategyMoveInput

a strategy moved to a place in its life, with the reason

[figure: StrategyMoveInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `strategy` | `id` | yes |  |
| `to` | `one of drafted \| simulated \| rolled out in part \| running \| paused \| ended` | yes |  |
| `reason` | `text` | yes |  |



## Routes that use it
- [`/v1/act/move_strategy`](/reference/act/move_strategy) takes it as input


---
title: "StrategyReadInput"
description: "a strategy to read, as of a date"
section: concepts
address: /concepts/strategyreadinput
contract: 0476e35e6e275db5
---

# StrategyReadInput

a strategy to read, as of a date

[figure: StrategyReadInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `strategy` | `id` | yes |  |
| `as_of` | `date` | no |  |



## Routes that use it
- [`/v1/read/strategy`](/reference/read/strategy) takes it as input


---
title: "SubjectResolution"
description: "what a subject stands for when the predicate is armed: names, keys and meaning"
section: concepts
address: /concepts/subjectresolution
contract: 0476e35e6e275db5
---

# SubjectResolution

what a subject stands for when the predicate is armed: names, keys and meaning

[figure: SubjectResolution is a fact at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | follows |
| key | the subject a leaf names, and its version |
| store | postgres+lake |
| family | rules_engine |



## Fields


| field | type | required | note |
|---|---|---|---|
| `subject` | `text` | yes |  |
| `entity` | `id` | no |  |
| `names` | `[text]` | yes |  |
| `keys` | [Identifier](/concepts/identifier) | yes |  |
| `vector` | [Vector](/concepts/vector) | no |  |
| `version` | `count` | yes |  |



## Routes that use it
No route takes or returns SubjectResolution directly. The record holds it, and the objects that point at it reach it.


---
title: "SubscriptionPlan"
description: "the limits a tenant receives, each a parameter of the receive family, and its kind: trial, paid or internal; acquisition never reads it"
section: concepts
address: /concepts/subscriptionplan
contract: 0476e35e6e275db5
---

# SubscriptionPlan

the limits a tenant receives, each a parameter of the receive family, and its kind: trial, paid or internal; acquisition never reads it

[figure: SubscriptionPlan is a definition at tenant scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | tenant |
| key | the tenant and its dates |
| store | postgres |
| family | people |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `tenant` | `id` | no | the tenant the plan limits; absent on a plan embedded in a tenant's row at sign-up |
| `leads_per_period` | `count` | yes | enforced at delivery, counted across the tenant's brands |
| `period` | `duration` | yes |  |
| `definitions_armed` | `count` | no |  |
| `starts_at` | `time` | yes |  |
| `ends_at` | `time` | no |  |
| `kind` | `one of trial \| paid \| internal` | yes |  |
| `ends` | `date` | no | a trial's end |



## Routes that use it
No route takes or returns SubscriptionPlan directly. The record holds it, and the objects that point at it reach it.


---
title: "Summary"
description: "a count, share, rank or ratio in one of three positions, never folded"
section: concepts
address: /concepts/summary
contract: 0476e35e6e275db5
---

# Summary

a count, share, rank or ratio in one of three positions, never folded

[figure: Summary is a fact at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | follows |
| key | the predicate, its own definition and the window |
| store | postgres |
| family | rules_engine |



## Fields


| field | type | required | note |
|---|---|---|---|
| `position` | `one of measured \| never measured \| withheld` | yes |  |
| `value` | `json` | no | only for measured, which may be zero |
| `reason` | `text` | no | for never measured |
| `withheld_count` | `count` | no |  |
| `coverage` | [ChannelCoverage](/concepts/channelcoverage) | yes |  |
| `population` | [PopulationStatement](/concepts/populationstatement) | yes |  |
| `predicate_version` | `hash` | yes |  |
| `definition_version` | `count` | yes |  |



## Routes that use it
No route takes or returns Summary directly. The record holds it, and the objects that point at it reach it.


---
title: "Surface"
description: "one node of the architecture: its route, the object it shows, its owner, its class, who sees it, its nine states"
section: concepts
address: /concepts/surface
contract: 0476e35e6e275db5
---

# Surface

one node of the architecture: its route, the object it shows, its owner, its class, who sees it, its nine states

[figure: Surface is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | its node |
| store | postgres |
| family | interfaces |



## Fields


| field | type | required | note |
|---|---|---|---|
| `node` | `text` | yes | N-nn |
| `route` | `text` | yes |  |
| `shows` | [Kind](/concepts/kind) | yes |  |
| `owner` | `text` | yes |  |
| `class` | `one of persistent \| dismissible \| working` | yes |  |
| `slot` | `text` | yes |  |
| `states` | `[one of default \| loading \| empty \| never measured \| partial \| degraded \| refused \| error \| stale]` | yes |  |
| `drawing` | `text` | yes | the figure |



## Routes that use it
No route takes or returns Surface directly. The record holds it, and the objects that point at it reach it.


---
title: "SyncOffer"
description: "a pairing a connector offers: which kind of reading with which kind of action, over which identity link"
section: concepts
address: /concepts/syncoffer
contract: 0476e35e6e275db5
---

# SyncOffer

a pairing a connector offers: which kind of reading with which kind of action, over which identity link

[figure: SyncOffer is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `reading` | `text` | yes |  |
| `action` | `text` | yes |  |
| `identity_link` | `text` | yes | the source id namespace bound to an identifier namespace |
| `directions` | `[one of pull \| push \| both]` | yes |  |



## Routes that use it
No route takes or returns SyncOffer directly. The record holds it, and the objects that point at it reach it.


---
title: "SyncPreview"
description: "what a sync rule would read and push, before it is armed"
section: concepts
address: /concepts/syncpreview
contract: 0476e35e6e275db5
---

# SyncPreview

what a sync rule would read and push, before it is armed

[figure: SyncPreview is a view at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `would_read` | `count` | yes |  |
| `would_push` | `[id]` | yes |  |
| `conflicts` | `count` | yes |  |



## Routes that use it
- [`/v1/act/sync_rule`](/reference/act/sync_rule) returns it


---
title: "SyncRule"
description: "one way or two ways from the same rows: pull arms cells, push runs as a move, a conflict is decided by the rule"
section: concepts
address: /concepts/syncrule
contract: 0476e35e6e275db5
---

# SyncRule

one way or two ways from the same rows: pull arms cells, push runs as a move, a conflict is decided by the rule

[figure: SyncRule is a definition at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | follows |
| key | the installed connector and the offer, versioned |
| store | postgres |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `installed_connector` | `id` | yes |  |
| `offer` | [SyncOffer](/concepts/syncoffer) | yes |  |
| `direction` | `one of pull \| push \| both` | yes |  |
| `push_mappings` | [PushMapping](/concepts/pushmapping) | yes | the reverse of the mapping's pull side |
| `pushes` | [Predicate](/concepts/predicate) | no | over entities or leads, previewed first |
| `conflict` | `one of the source wins \| the record wins \| the newest valid time wins \| ask` | yes |  |
| `cadence` | `duration` | no | pull arms cells at it |
| `grant` | `id` | yes | the mode a push runs under |
| `state` | [Readiness](/concepts/readiness) | yes |  |



## Routes that use it
No route takes or returns SyncRule directly. The record holds it, and the objects that point at it reach it.


---
title: "SyncRuleInput"
description: "a sync rule to write, preview or arm"
section: concepts
address: /concepts/syncruleinput
contract: 0476e35e6e275db5
---

# SyncRuleInput

a sync rule to write, preview or arm

[figure: SyncRuleInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `rule` | [SyncRule](/concepts/syncrule) | yes |  |
| `flow` | `one of write \| preview \| arm \| disarm` | yes |  |



## Routes that use it
- [`/v1/act/sync_rule`](/reference/act/sync_rule) takes it as input


---
title: "SystemsModelsInput"
description: "the vertical or the kind of offering the templates must fit; both absent asks for every template"
section: concepts
address: /concepts/systemsmodelsinput
contract: 0476e35e6e275db5
---

# SystemsModelsInput

the vertical or the kind of offering the templates must fit; both absent asks for every template

[figure: SystemsModelsInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `vertical` | `id` | no |  |
| `kind_of_offering` | [KindOfOffering](/concepts/kindofoffering) | no |  |



## Routes that use it
- [`/v1/read/systems_models`](/reference/read/systems_models) takes it as input


---
title: "SystemsModelTemplate"
description: "one systems model of a market, written as rows over the calculation shapes and the predicates: its stocks, its flows, its loops, its delays and its parameters, for a family of verticals and kinds of offering; versioned; carries a planted defect so its check can go red"
section: concepts
address: /concepts/systemsmodeltemplate
contract: 0476e35e6e275db5
---

# SystemsModelTemplate

one systems model of a market, written as rows over the calculation shapes and the predicates: its stocks, its flows, its loops, its delays and its parameters, for a family of verticals and kinds of offering; versioned; carries a planted defect so its check can go red

[figure: SystemsModelTemplate is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | its name and version |
| store | postgres |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `version` | `count` | yes |  |
| `what` | `text` | yes | the market it models, in one sentence |
| `vertical_family` | `text` | yes | the family of verticals it fits, in the verticals model's words |
| `kinds_of_offering` | [KindOfOffering](/concepts/kindofoffering) | yes |  |
| `stocks` | [ModelStock](/concepts/modelstock) | yes |  |
| `flows` | [ModelFlow](/concepts/modelflow) | yes |  |
| `loops` | [FeedbackLoop](/concepts/feedbackloop) | yes |  |
| `shapes` | [CalculationShape](/concepts/calculationshape) | yes | the calculation shapes its money flows compose |
| `parameters` | `[text]` | yes | the parameter rows it reads, by name |
| `outputs` | `[text]` | yes | the stocks and gains a simulation reports |
| `step` | `duration` | yes |  |
| `horizon` | `duration` | yes |  |
| `family` | [ModelFamily](/concepts/modelfamily) | yes | the model family the template is written in |
| `way` | [WayOfGoingToMarket](/concepts/wayofgoingtomarket) | no | the way of going to market the template serves, where one fits |
| `game` | [GameOfRoles](/concepts/gameofroles) | no | the game of roles laid over the template, where the family carries one |
| `planted_defect` | `text` | yes | the fault the template carries in its check mode, so the check is proved able to go red |
| `state` | [Readiness](/concepts/readiness) | yes |  |
| `content_hash` | `hash` | yes |  |



## Routes that use it
No route takes or returns SystemsModelTemplate directly. The record holds it, and the objects that point at it reach it.


---
title: "Tactic"
description: "the named, reusable method that a move applies; what works is learned tactic by tactic; the catalogue of the standard mechanisms people use to find product-market fit is rows of this register, each with the phase of the search it serves"
section: concepts
address: /concepts/tactic
contract: 0476e35e6e275db5
---

# Tactic

the named, reusable method that a move applies; what works is learned tactic by tactic; the catalogue of the standard mechanisms people use to find product-market fit is rows of this register, each with the phase of the search it serves

[figure: Tactic is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | its name |
| store | postgres |
| family | strategy |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `forecasts_against_effects` | `[id]` | yes |  |
| `phase` | `one of find the market \| sculpt the offering \| test the fit \| build a beachhead \| engineer demand \| find demand \| grow in a market \| hedge` | no | the phase of the search for product-market fit it serves; absent for a tactic of the plays alone |
| `mechanism` | `text` | no | what the tactic does, in the field's terms |
| `deciding_number` | `text` | no | the number that says it worked, and its bar |
| `control` | `text` | no | the control read in the same run |
| `known_failure` | `text` | no | the way it goes wrong, and the answer |
| `applies_to_kinds_of_offering` | [KindOfOffering](/concepts/kindofoffering) | no | empty means every kind |
| `applies_to_verticals` | `[text]` | no | the vertical families it fits, by name; empty means every vertical |
| `library_method` | `text` | no | the method of the methodology library it runs, by name, where one exists |



## Routes that use it
No route takes or returns Tactic directly. The record holds it, and the objects that point at it reach it.


---
title: "Task"
description: "a run a caller started through a tool: its progress, what it asks, and how it ended"
section: concepts
address: /concepts/task
contract: 0476e35e6e275db5
---

# Task

a run a caller started through a tool: its progress, what it asks, and how it ended

[figure: Task is a view at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | none |
| key | the run, as one caller sees it |
| store | derived |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `run` | `id` | yes |  |
| `progress` | [Progress](/concepts/progress) | yes |  |
| `asks` | [TaskQuestion](/concepts/taskquestion) | yes |  |
| `ended` | `one of running \| waiting \| ended \| failed \| stopped` | yes |  |
| `result` | [Card](/concepts/card) | no |  |



## Routes that use it
- [`/v1/work/run_procedure`](/reference/work/run_procedure) returns it
- [`/v1/work/status`](/reference/work/status) returns it
- [`/v1/work/local_procedure`](/reference/work/local_procedure) returns it
- [`/v1/harness/delegate`](/reference/harness/delegate) returns it


---
title: "TaskQuestion"
description: "a question a run asks the caller; answering it is the one approval"
section: concepts
address: /concepts/taskquestion
contract: 0476e35e6e275db5
---

# TaskQuestion

a question a run asks the caller; answering it is the one approval

[figure: TaskQuestion is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `id` | `id` | yes |  |
| `what` | `text` | yes |  |
| `options` | `[text]` | no |  |
| `answered` | `json` | no |  |
| `by` | [Caller](/concepts/caller) | no |  |



## Routes that use it
No route takes or returns TaskQuestion directly. The record holds it, and the objects that point at it reach it.


---
title: "TelemetryContext"
description: "the W3C trace context every call, event and message carries: the trace id, the parent span, and the attributes the platform adds"
section: concepts
address: /concepts/telemetrycontext
contract: 0476e35e6e275db5
---

# TelemetryContext

the W3C trace context every call, event and message carries: the trace id, the parent span, and the attributes the platform adds

[figure: TelemetryContext is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | observability |



## Fields


| field | type | required | note |
|---|---|---|---|
| `trace_id` | `hash` | yes |  |
| `parent_span_id` | `hash` | no |  |
| `tenant` | `id` | no |  |
| `scope` | [Scope](/concepts/scope) | no |  |
| `tool` | `text` | no |  |
| `job_key` | `text` | no | the durable job's idempotency key, so a trace and a job are joined |



## Routes that use it
No route takes or returns TelemetryContext directly. The record holds it, and the objects that point at it reach it.


---
title: "Telling"
description: "an address a tenant registered to be told at, with its signed calls as durable work"
section: concepts
address: /concepts/telling
contract: 0476e35e6e275db5
---

# Telling

an address a tenant registered to be told at, with its signed calls as durable work

[figure: Telling is a definition at tenant scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | tenant |
| key | the tenant, the address and the kinds |
| store | postgres |
| family | gateway |



## Fields


| field | type | required | note |
|---|---|---|---|
| `tenant` | `id` | yes |  |
| `address` | `address` | yes |  |
| `kinds` | [Flow](/concepts/flow) | yes |  |
| `secret` | `id` | yes | a vault entry |
| `tries_bound` | `count` | yes |  |
| `failed_calls` | [FailedCall](/concepts/failedcall) | yes |  |



## Routes that use it
- [`/v1/act/webhook`](/reference/act/webhook) returns it


---
title: "Template"
description: "a segment's vertical pack: rows a brand installs as copies naming their origin; its own origin is the vertical's pack; it carries a planted defect"
section: concepts
address: /concepts/template
contract: 0476e35e6e275db5
---

# Template

a segment's vertical pack: rows a brand installs as copies naming their origin; its own origin is the vertical's pack; it carries a planted defect

[figure: Template is a definition at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | platform |
| key | the segment and its version |
| store | postgres |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `vertical` | `id` | yes |  |
| `segment` | `id` | yes |  |
| `version` | `count` | yes |  |
| `origin` | `id` | no | the vertical's pack |
| `kinds_of_buyer` | [KindOfBuyer](/concepts/kindofbuyer) | yes | originals |
| `ladders` | [Ladder](/concepts/ladder) | yes |  |
| `kinds_of_signal` | [KindOfSignal](/concepts/kindofsignal) | yes |  |
| `sources` | [Source](/concepts/source) | yes |  |
| `plays` | [Play](/concepts/play) | yes |  |
| `channels` | [ChannelRule](/concepts/channelrule) | yes |  |
| `words` | [Word](/concepts/word) | yes |  |
| `regulations` | [Regulation](/concepts/regulation) | yes |  |
| `facets` | `[id]` | yes |  |
| `proxies` | `[id]` | yes |  |
| `ways_of_going_to_market` | [WayOfGoingToMarket](/concepts/wayofgoingtomarket) | yes |  |
| `planted_defect` | `text` | yes | the install must refuse it |
| `state` | [Readiness](/concepts/readiness) | yes |  |



## Routes that use it
No route takes or returns Template directly. The record holds it, and the objects that point at it reach it.


---
title: "TemplateInput"
description: "an extraction template to write, preview, arm or retire"
section: concepts
address: /concepts/templateinput
contract: 0476e35e6e275db5
---

# TemplateInput

an extraction template to write, preview, arm or retire

[figure: TemplateInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `template` | [ExtractionTemplate](/concepts/extractiontemplate) | yes |  |
| `flow` | `one of write \| preview \| arm \| disarm \| retire` | yes |  |



## Routes that use it
- [`/v1/act/scrape_template`](/reference/act/scrape_template) takes it as input


---
title: "Tenant"
description: "a tenant: Tenant, a entity of the people family at platform scope"
section: concepts
address: /concepts/tenant
contract: 0476e35e6e275db5
---

# Tenant

a tenant: Tenant, a entity of the people family at platform scope

[figure: Tenant is a entity at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | entity |
| scope | platform |
| key | its id |
| store | postgres |
| family | people |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `company` | `id` | yes | the entity of the record it is |
| `plan` | [SubscriptionPlan](/concepts/subscriptionplan) | yes |  |
| `autonomy_ceiling` | `{text:enum:read only \| propose \| act \| full autonomy}` | yes | for each kind of reach |
| `state` | [Readiness](/concepts/readiness) | yes | not ready with its reason when suspended |
| `retired_at` | `time` | no |  |



## Routes that use it
- [`/v1/act/sign_up`](/reference/act/sign_up) returns it


---
title: "Thread"
description: "the durable container of one conversation between a user and the agent; created, resumed, forked and archived; its history is the event log"
section: concepts
address: /concepts/thread
contract: 0476e35e6e275db5
---

# Thread

the durable container of one conversation between a user and the agent; created, resumed, forked and archived; its history is the event log

[figure: Thread is a work at strategy scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | work |
| scope | strategy |
| key | its id |
| store | postgres |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `id` | `id` | yes |  |
| `strategy` | `id` | yes |  |
| `user` | `id` | yes |  |
| `title` | `text` | no |  |
| `forked_from` | `id` | no |  |
| `cursor` | [EventCursor](/concepts/eventcursor) | yes | the last event a client rendered |



## Routes that use it
No route takes or returns Thread directly. The record holds it, and the objects that point at it reach it.


---
title: "Tile"
description: "one tile of a board: a saved question, a chart kind, a period and the comparison with the period before"
section: concepts
address: /concepts/tile
contract: 0476e35e6e275db5
---

# Tile

one tile of a board: a saved question, a chart kind, a period and the comparison with the period before

[figure: Tile is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | ops_console |



## Fields


| field | type | required | note |
|---|---|---|---|
| `question` | [SavedQuestion](/concepts/savedquestion) | yes |  |
| `chart` | `one of a number \| a series over time \| a bar by kind \| a table` | yes |  |
| `period` | [Window](/concepts/window) | no | the board's when empty |
| `compare` | `bool` | yes | with the period before |



## Routes that use it
No route takes or returns Tile directly. The record holds it, and the objects that point at it reach it.


---
title: "TimeWithBasis"
description: "a time with what it means"
section: concepts
address: /concepts/timewithbasis
contract: 0476e35e6e275db5
---

# TimeWithBasis

a time with what it means

[figure: TimeWithBasis is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | kernel |



## Fields


| field | type | required | note |
|---|---|---|---|
| `at` | `time` | yes |  |
| `basis` | `one of published \| scheduled \| first seen \| read \| computed` | yes |  |
| `precision` | `one of instant \| day \| month \| year` | yes |  |



## Routes that use it
No route takes or returns TimeWithBasis directly. The record holds it, and the objects that point at it reach it.


---
title: "Token"
description: "the claims of an access token; the gateway checks six of them and grants nothing on the token alone"
section: concepts
address: /concepts/token
contract: 0476e35e6e275db5
---

# Token

the claims of an access token; the gateway checks six of them and grants nothing on the token alone

[figure: Token is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | people |



## Fields


| field | type | required | note |
|---|---|---|---|
| `token_use` | `one of access` | yes | it is marked as an access token |
| `subject` | `text` | yes |  |
| `issuer` | `address` | yes |  |
| `client` | `id` | yes | which client it was given to |
| `audience` | `text` | yes | which service it is made out to |
| `expires_at` | `time` | yes |  |
| `signed_in_strength` | `text` | no |  |
| `signed_in_at` | `time` | no |  |
| `access_scopes` | [AccessScope](/concepts/accessscope) | yes |  |
| `acting_for` | `[text]` | no | outermost first |
| `bound_key` | `hash` | no | the holder's key it is tied to |



## Routes that use it
No route takes or returns Token directly. The record holds it, and the objects that point at it reach it.


---
title: "Tool"
description: "a capability from the tool register, with its inputs and outputs as owning types; generated, never written by hand"
section: concepts
address: /concepts/tool
contract: 0476e35e6e275db5
---

# Tool

a capability from the tool register, with its inputs and outputs as owning types; generated, never written by hand

[figure: Tool is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | its name |
| store | postgres |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes | si.<family>.<verb> |
| `family` | `one of session \| ask \| read \| view \| act \| work \| harness \| files` | yes |  |
| `from_row` | `text` | yes | the specification's interface row |
| `input_type` | `text` | yes | a type of this register |
| `output_type` | `text` | yes | the body of the card |
| `rung` | `one of user \| tenant \| brand \| strategy` | yes |  |
| `grant` | `one of read \| ask \| act \| work \| files \| admin` | yes |  |
| `where` | `one of platform \| app \| either` | yes |  |
| `long` | `bool` | yes | returns a task |
| `exposure` | `one of direct \| deferred \| workbench` | yes | direct is in the first list a model sees; deferred is reached by paging one family at a time; workbench only from code in the workbench |
| `permission` | [Permission](/concepts/permission) | yes |  |
| `state` | [Readiness](/concepts/readiness) | yes | off for a tenant is absent from the list |
| `takes` | `text` | yes | the plain sentence of what the tool takes, as the tool register prints it |
| `gives` | `text` | yes | the plain sentence of what the tool gives |



## Routes that use it
No route takes or returns Tool directly. The record holds it, and the objects that point at it reach it.


---
title: "ToolCall"
description: "one call of a tool inside a turn: the tool, its inputs, and what it became, a card or a refusal"
section: concepts
address: /concepts/toolcall
contract: 0476e35e6e275db5
---

# ToolCall

one call of a tool inside a turn: the tool, its inputs, and what it became, a card or a refusal

[figure: ToolCall is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `tool` | [Tool](/concepts/tool) | yes |  |
| `inputs` | `json` | yes | the tool's input type, serialized |
| `card` | [Card](/concepts/card) | no | the answer, once the call completed |
| `refusal` | [Refusal](/concepts/refusal) | no | why it was not run, once the call failed |



## Routes that use it
No route takes or returns ToolCall directly. The record holds it, and the objects that point at it reach it.


---
title: "ToolMeta"
description: "what a listed MCP tool carries beside its schema: its row as the register holds it and the release's stamp"
section: concepts
address: /concepts/toolmeta
contract: 0476e35e6e275db5
---

# ToolMeta

what a listed MCP tool carries beside its schema: its row as the register holds it and the release's stamp

[figure: ToolMeta is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `tool` | [Tool](/concepts/tool) | yes | the row |
| `register_hash` | `hash` | yes | the register the row is from |
| `built_in_this_release` | `bool` | yes |  |



## Routes that use it
No route takes or returns ToolMeta directly. The record holds it, and the objects that point at it reach it.


---
title: "TouchedBuckets"
description: "for one table of gold, the entity buckets an acceptance touched and the snapshot it made; a reader is stale when its read set meets them"
section: concepts
address: /concepts/touchedbuckets
contract: 0476e35e6e275db5
---

# TouchedBuckets

for one table of gold, the entity buckets an acceptance touched and the snapshot it made; a reader is stale when its read set meets them

[figure: TouchedBuckets is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | record |



## Fields


| field | type | required | note |
|---|---|---|---|
| `table` | `text` | yes |  |
| `buckets` | `[count]` | yes | bounded by the bucket parameter |
| `snapshot` | `count` | yes |  |



## Routes that use it
No route takes or returns TouchedBuckets directly. The record holds it, and the objects that point at it reach it.


---
title: "Trail"
description: "every access and every administrator's change, with the hash chain over it"
section: concepts
address: /concepts/trail
contract: 0476e35e6e275db5
---

# Trail

every access and every administrator's change, with the hash chain over it

[figure: Trail is a view at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | platform |
| key | the tenant, or the platform |
| store | derived |
| family | operations |



## Fields


| field | type | required | note |
|---|---|---|---|
| `owner` | `one of a tenant \| the platform` | yes |  |
| `entries` | [Event](/concepts/event) | yes |  |
| `chain_hash` | `hash` | yes |  |
| `proved_whole_at` | `time` | no |  |



## Routes that use it
No route takes or returns Trail directly. The record holds it, and the objects that point at it reach it.


---
title: "Trajectory"
description: "plan item to grounded move to outcome, for each move in the window"
section: concepts
address: /concepts/trajectory
contract: 0476e35e6e275db5
---

# Trajectory

plan item to grounded move to outcome, for each move in the window

[figure: Trajectory is a view at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `moves` | [MoveTrajectory](/concepts/movetrajectory) | yes |  |
| `window` | [Window](/concepts/window) | yes |  |



## Routes that use it
- [`/v1/read/trajectory`](/reference/read/trajectory) returns it


---
title: "TrajectoryInput"
description: "a strategy's or one move's trajectory over a window"
section: concepts
address: /concepts/trajectoryinput
contract: 0476e35e6e275db5
---

# TrajectoryInput

a strategy's or one move's trajectory over a window

[figure: TrajectoryInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `strategy` | `id` | no |  |
| `move` | `id` | no |  |
| `window` | [Window](/concepts/window) | no |  |



## Routes that use it
- [`/v1/read/trajectory`](/reference/read/trajectory) takes it as input


---
title: "TransportKind"
description: "one way of connecting, with one shared client; a transport inside a connector is a defect"
section: concepts
address: /concepts/transportkind
contract: 0476e35e6e275db5
---

# TransportKind

one way of connecting, with one shared client; a transport inside a connector is a defect

[figure: TransportKind is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | its name |
| store | postgres |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `one of HTTPS REST \| GraphQL \| gRPC \| WebSocket \| server-sent events \| an inbound webhook \| a feed \| SFTP \| an object store \| a database wire \| IMAP and SMTP \| a bulk file \| a rendered page \| a person's own browser \| metasearch \| a browsing session \| a file a user brings` | yes | The short name of the transport. The table in 18 §2.2 lists the members of each kind after a colon or a comma. |
| `client` | `text` | yes | the shared client module |
| `credential_kinds` | `[text]` | yes | the kinds it takes |
| `cursor_kinds` | `[text]` | yes |  |
| `can_push` | `bool` | yes |  |



## Routes that use it
No route takes or returns TransportKind directly. The record holds it, and the objects that point at it reach it.


---
title: "Turn"
description: "one unit of the agent's work, started by one input and ended when its outputs are produced; it holds items in order"
section: concepts
address: /concepts/turn
contract: 0476e35e6e275db5
---

# Turn

one unit of the agent's work, started by one input and ended when its outputs are produced; it holds items in order

[figure: Turn is a work at strategy scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | work |
| scope | strategy |
| key | the thread and its sequence |
| store | postgres |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `thread` | `id` | yes |  |
| `sequence` | `count` | yes |  |
| `input` | `text` | yes |  |
| `started_at` | `time` | yes |  |
| `ended_at` | `time` | no |  |
| `outcome` | `one of completed \| cancelled \| failed \| waiting` | no |  |
| `items` | [Item](/concepts/item) | yes |  |



## Routes that use it
No route takes or returns Turn directly. The record holds it, and the objects that point at it reach it.


---
title: "TwoDates"
description: "the two dates that every read specifies: the date it was true and the date we knew it; both default to now"
section: concepts
address: /concepts/twodates
contract: 0476e35e6e275db5
---

# TwoDates

the two dates that every read specifies: the date it was true and the date we knew it; both default to now

[figure: TwoDates is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | kernel |



## Fields


| field | type | required | note |
|---|---|---|---|
| `as_true_on` | `time` | yes |  |
| `as_known_on` | `time` | yes |  |



## Routes that use it
No route takes or returns TwoDates directly. The record holds it, and the objects that point at it reach it.


---
title: "UnderTestInput"
description: "a unit, a brand or a scope"
section: concepts
address: /concepts/undertestinput
contract: 0476e35e6e275db5
---

# UnderTestInput

a unit, a brand or a scope

[figure: UnderTestInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `about` | [UnitRef](/concepts/unitref) | no |  |
| `scope` | [Scope](/concepts/scope) | no |  |
| `standing` | `one of under test \| supported \| refuted \| cannot tell \| all` | no |  |



## Routes that use it
- [`/v1/read/under_test`](/reference/read/under_test) takes it as input


---
title: "UndoActionInput"
description: "the move to undo"
section: concepts
address: /concepts/undoactioninput
contract: 0476e35e6e275db5
---

# UndoActionInput

the move to undo

[figure: UndoActionInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `move` | `id` | yes |  |



## Routes that use it
- [`/v1/act/undo_action`](/reference/act/undo_action) takes it as input


---
title: "UndoAnswer"
description: "the action undone, and the inverse's own action"
section: concepts
address: /concepts/undoanswer
contract: 0476e35e6e275db5
---

# UndoAnswer

the action undone, and the inverse's own action

[figure: UndoAnswer is a view at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `action` | [Action](/concepts/action) | yes |  |
| `inverse` | [Action](/concepts/action) | yes |  |



## Routes that use it
- [`/v1/act/undo`](/reference/act/undo) returns it


---
title: "UndoInput"
description: "an action to undo"
section: concepts
address: /concepts/undoinput
contract: 0476e35e6e275db5
---

# UndoInput

an action to undo

[figure: UndoInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `action` | `id` | yes |  |
| `reason` | `text` | yes |  |



## Routes that use it
- [`/v1/act/undo`](/reference/act/undo) takes it as input


---
title: "UndoMergeAnswer"
description: "a parting, or a later decision with the facts written again"
section: concepts
address: /concepts/undomergeanswer
contract: 0476e35e6e275db5
---

# UndoMergeAnswer

a parting, or a later decision with the facts written again

[figure: UndoMergeAnswer is a view at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `parting` | [Parting](/concepts/parting) | no |  |
| `decision` | [IdentityDecision](/concepts/identitydecision) | no |  |



## Routes that use it
- [`/v1/act/undo_merge`](/reference/act/undo_merge) returns it


---
title: "UndoMergeInput"
description: "a merge to undo, or a decision to undo"
section: concepts
address: /concepts/undomergeinput
contract: 0476e35e6e275db5
---

# UndoMergeInput

a merge to undo, or a decision to undo

[figure: UndoMergeInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `merge` | `id` | no |  |
| `decision` | `id` | no |  |
| `reason` | `text` | yes |  |



## Routes that use it
- [`/v1/act/undo_merge`](/reference/act/undo_merge) takes it as input


---
title: "Unit"
description: "what every unit carries, whatever its type"
section: concepts
address: /concepts/unit
contract: 0476e35e6e275db5
---

# Unit

what every unit carries, whatever its type

[figure: Unit is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | every unit carries these |
| store | none |
| family | kernel |



## Fields


| field | type | required | note |
|---|---|---|---|
| `id` | `id` | yes | opaque, ordered by time, given once by the kernel; never made from an attribute |
| `kind` | [Kind](/concepts/kind) | yes | a registered kind; an unregistered kind cannot be named in code |
| `key` | `text` | no | for a kind that is the same by construction, made from the input; two units of one kind never share one |
| `scope` | [Scope](/concepts/scope) | yes | never widens; a unit made from others lives at the narrowest |
| `made_at` | `time` | yes | set once |
| `made_by` | [Caller](/concepts/caller) | yes | the caller with the run |
| `trace` | `id` | yes | the run that made or moved it, set on every flow |



## Routes that use it
- [`/v1/read/unit`](/reference/read/unit) returns it


---
title: "UnitRef"
description: "one unit by its id and kind"
section: concepts
address: /concepts/unitref
contract: 0476e35e6e275db5
---

# UnitRef

one unit by its id and kind

[figure: UnitRef is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `id` | `id` | yes |  |
| `kind` | [Kind](/concepts/kind) | yes |  |



## Routes that use it
- [`/v1/read/explain_catch`](/reference/read/explain_catch) takes it as input
- [`/v1/read/unit`](/reference/read/unit) takes it as input
- [`/v1/act/annotate`](/reference/act/annotate) returns it


---
title: "UploadInput"
description: "a file in the workspace to upload"
section: concepts
address: /concepts/uploadinput
contract: 0476e35e6e275db5
---

# UploadInput

a file in the workspace to upload

[figure: UploadInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `path` | `text` | yes |  |
| `kind` | [UserProvidedContentKind](/concepts/userprovidedcontentkind) | yes |  |



## Routes that use it
- [`/v1/files/upload`](/reference/files/upload) takes it as input


---
title: "UsageInput"
description: "usage by tenant, kind, provider and window, for platform administrators"
section: concepts
address: /concepts/usageinput
contract: 0476e35e6e275db5
---

# UsageInput

usage by tenant, kind, provider and window, for platform administrators

[figure: UsageInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `tenant` | `id` | no |  |
| `kind` | [KindOfUsage](/concepts/kindofusage) | no |  |
| `provider` | `text` | no |  |
| `window` | [Window](/concepts/window) | yes |  |



## Routes that use it
- [`/v1/view/usage`](/reference/view/usage) takes it as input


---
title: "UsageReconciliation"
description: "the metered total against the provider's bill for one day, with the count and sum of discrepancies; ready only under the tolerance"
section: concepts
address: /concepts/usagereconciliation
contract: 0476e35e6e275db5
---

# UsageReconciliation

the metered total against the provider's bill for one day, with the count and sum of discrepancies; ready only under the tolerance

[figure: UsageReconciliation is a fact at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | follows |
| key | the provider and the day |
| store | postgres |
| family | operations |



## Fields


| field | type | required | note |
|---|---|---|---|
| `provider` | `text` | yes |  |
| `day` | `time` | yes |  |
| `metered` | [Cost](/concepts/cost) | yes |  |
| `billed` | [Cost](/concepts/cost) | yes |  |
| `discrepancies` | `count` | yes |  |
| `discrepancy_sum` | [Cost](/concepts/cost) | yes |  |
| `state` | [Readiness](/concepts/readiness) | yes |  |



## Routes that use it
No route takes or returns UsageReconciliation directly. The record holds it, and the objects that point at it reach it.


---
title: "UsageReport"
description: "quantity and cost by kind, by tenant, by provider and by period, with each provider's reconciliation state"
section: concepts
address: /concepts/usagereport
contract: 0476e35e6e275db5
---

# UsageReport

quantity and cost by kind, by tenant, by provider and by period, with each provider's reconciliation state

[figure: UsageReport is a view at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `rows` | [MeteredUsage](/concepts/meteredusage) | yes |  |
| `totals` | `{text:Cost}` | yes | by kind |
| `reconciliations` | [UsageReconciliation](/concepts/usagereconciliation) | yes |  |



## Routes that use it
- [`/v1/view/usage`](/reference/view/usage) returns it


---
title: "UsageStatement"
description: "a tenant's metered usage of a period by kind, priced, against the plan's included quantities"
section: concepts
address: /concepts/usagestatement
contract: 0476e35e6e275db5
---

# UsageStatement

a tenant's metered usage of a period by kind, priced, against the plan's included quantities

[figure: UsageStatement is a view at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | none |
| key | none |
| store | derived |
| family | operations |



## Fields


| field | type | required | note |
|---|---|---|---|
| `period` | [Window](/concepts/window) | yes |  |
| `lines` | `[json]` | yes | kind, quantity, included, over, price, amount |
| `total` | `money` | yes |  |
| `plan_kind` | `one of trial \| paid \| internal` | yes |  |



## Routes that use it
- [`/v1/read/usage_statement`](/reference/read/usage_statement) returns it


---
title: "UsageStatementInput"
description: "the period of a usage statement"
section: concepts
address: /concepts/usagestatementinput
contract: 0476e35e6e275db5
---

# UsageStatementInput

the period of a usage statement

[figure: UsageStatementInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `period` | [Window](/concepts/window) | yes |  |



## Routes that use it
- [`/v1/read/usage_statement`](/reference/read/usage_statement) takes it as input


---
title: "User"
description: "a person, only through a sign-in; the platform holds no password"
section: concepts
address: /concepts/user
contract: 0476e35e6e275db5
---

# User

a person, only through a sign-in; the platform holds no password

[figure: User is a entity at tenant scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | entity |
| scope | tenant |
| key | the provider and the subject |
| store | postgres |
| family | people |



## Fields


| field | type | required | note |
|---|---|---|---|
| `provider` | [SignInProvider](/concepts/signinprovider) | yes |  |
| `subject` | `text` | yes | the subject the provider gives |
| `name` | `text` | yes |  |
| `mail` | `address` | no |  |
| `chat_member_id` | `text` | no | once a workspace is tied |
| `home_tenant` | `id` | yes |  |



## Routes that use it
No route takes or returns User directly. The record holds it, and the objects that point at it reach it.


---
title: "UserMessage"
description: "what a person typed into a turn"
section: concepts
address: /concepts/usermessage
contract: 0476e35e6e275db5
---

# UserMessage

what a person typed into a turn

[figure: UserMessage is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `text` | `text` | yes |  |



## Routes that use it
No route takes or returns UserMessage directly. The record holds it, and the objects that point at it reach it.


---
title: "UserProvidedContentKind"
description: "a kind of user-provided content, a file, a pasted list, a photo, a link: how it is read and what may join a shared entity"
section: concepts
address: /concepts/userprovidedcontentkind
contract: 0476e35e6e275db5
---

# UserProvidedContentKind

a kind of user-provided content, a file, a pasted list, a photo, a link: how it is read and what may join a shared entity

[figure: UserProvidedContentKind is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | its name |
| store | postgres |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `how_read` | `text` | yes |  |
| `resolves` | [KindOfEntity](/concepts/kindofentity) | yes |  |
| `may_join_shared` | `bool` | yes |  |



## Routes that use it
No route takes or returns UserProvidedContentKind directly. The record holds it, and the objects that point at it reach it.


---
title: "ValueChain"
description: "the chain of a vertical with the participants placed on its stocks, the loops the template names over it, and when it was read; answered from the chain, the participants and the readings and held nowhere"
section: concepts
address: /concepts/valuechain
contract: 0476e35e6e275db5
---

# ValueChain

the chain of a vertical with the participants placed on its stocks, the loops the template names over it, and when it was read; answered from the chain, the participants and the readings and held nowhere

[figure: ValueChain is a view at brand scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | brand |
| key | the vertical and the brand |
| store | derived |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `vertical` | `id` | yes |  |
| `chain` | `id` | yes |  |
| `stocks` | [ChainStock](/concepts/chainstock) | yes |  |
| `handovers` | [ChainHandover](/concepts/chainhandover) | yes |  |
| `participants` | [MarketParticipant](/concepts/marketparticipant) | yes |  |
| `loops` | [FeedbackLoop](/concepts/feedbackloop) | yes |  |
| `read_at` | `time` | yes |  |



## Routes that use it
- [`/v1/read/value_chain`](/reference/read/value_chain) returns it


---
title: "ValueChainInput"
description: "the vertical, and the brand whose participants are placed"
section: concepts
address: /concepts/valuechaininput
contract: 0476e35e6e275db5
---

# ValueChainInput

the vertical, and the brand whose participants are placed

[figure: ValueChainInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `vertical` | `id` | yes |  |
| `brand` | `id` | no |  |
| `segment` | `id` | no |  |



## Routes that use it
- [`/v1/read/value_chain`](/reference/read/value_chain) takes it as input


---
title: "VaultEntry"
description: "a secret, encrypted under its owner's key; never in a table, a log, an address or an event"
section: concepts
address: /concepts/vaultentry
contract: 0476e35e6e275db5
---

# VaultEntry

a secret, encrypted under its owner's key; never in a table, a log, an address or an event

[figure: VaultEntry is a definition at tenant scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | tenant |
| key | its owner and what it is for |
| store | vault |
| family | people |



## Fields


| field | type | required | note |
|---|---|---|---|
| `owner` | `one of the platform \| a tenant` | yes |  |
| `purpose` | `text` | yes |  |
| `versions` | [SecretVersion](/concepts/secretversion) | yes | each with who rotated it |
| `calls_that_may_use_it` | `[text]` | yes |  |
| `last_used_at` | `time` | no |  |
| `last_used_by_role` | `text` | no |  |
| `where_on` | `text` | yes |  |



## Routes that use it
No route takes or returns VaultEntry directly. The record holds it, and the objects that point at it reach it.


---
title: "Vector"
description: "a vector from a model that carries meaning, named by its model; never a hash"
section: concepts
address: /concepts/vector
contract: 0476e35e6e275db5
---

# Vector

a vector from a model that carries meaning, named by its model; never a hash

[figure: Vector is a fact at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | follows |
| key | the hash of the text, the model and the tier |
| store | postgres+lake |
| family | record |



## Fields


| field | type | required | note |
|---|---|---|---|
| `text_hash` | `hash` | yes |  |
| `model` | [Model](/concepts/model) | yes | a model whose row is ready |
| `tier` | `one of narrow \| wide` | yes |  |
| `width` | `count` | yes |  |
| `numbers` | `[number]` | yes | the vector's numbers at the model's width; the gold column keeps them at one byte a number for the narrow tier and at full precision for the wide, and the wire always carries the numbers |
| `centroid` | `count` | no | the centroid of the coarse index |
| `sketch` | `[count]` | no | the one-bit sketch for the first pass, as 64-bit words; its width is the parameter |
| `media_hash` | `hash` | no | for a vector of an image, a frame or a sound, in place of the text's hash |
| `unit` | `id` | no | the unit whose text was given meaning, when the text is one unit's: an entity, a content item, an observation |



## Routes that use it
No route takes or returns Vector directly. The record holds it, and the objects that point at it reach it.


---
title: "Verb"
description: "one of the words that order the public surface; a verb with no operation yet is shown as not yet served"
section: concepts
address: /concepts/verb
contract: 0476e35e6e275db5
---

# Verb

one of the words that order the public surface; a verb with no operation yet is shown as not yet served

[figure: Verb is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | its name |
| store | postgres |
| family | gateway |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `operations` | [Tool](/concepts/tool) | yes |  |
| `served` | `bool` | yes |  |



## Routes that use it
No route takes or returns Verb directly. The record holds it, and the objects that point at it reach it.


---
title: "Vertical"
description: "one market worked as a whole: its chain, its roles, its segments, its words and rules; ready or visibly not ready"
section: concepts
address: /concepts/vertical
contract: 0476e35e6e275db5
---

# Vertical

one market worked as a whole: its chain, its roles, its segments, its words and rules; ready or visibly not ready

[figure: Vertical is a definition at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | platform |
| key | its name |
| store | postgres |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `industries` | `[text]` | yes |  |
| `chain` | `id` | yes |  |
| `roles` | [RoleAroundADecision](/concepts/rolearoundadecision) | yes |  |
| `segments` | `[id]` | yes |  |
| `words` | [Word](/concepts/word) | yes |  |
| `regulations` | [Regulation](/concepts/regulation) | yes |  |
| `sources` | [Source](/concepts/source) | yes |  |
| `kinds_of_signal` | [KindOfSignal](/concepts/kindofsignal) | yes |  |
| `state` | [Readiness](/concepts/readiness) | yes |  |
| `industry_group` | `text` | no | the industry family it sits in, from the seed catalogue |
| `applications` | [Application](/concepts/application) | no | the customer questions it is worked for |
| `systems_models` | [SystemsModelTemplate](/concepts/systemsmodeltemplate) | no | the systems model templates that model its chain; a game of roles, where one is laid, is the template's own; every role that a template's flows or game name is one of the vertical's roles |



## Routes that use it
- [`/v1/read/vertical`](/reference/read/vertical) returns it


---
title: "VerticalInput"
description: "the vertical, or a brand whose vertical is meant"
section: concepts
address: /concepts/verticalinput
contract: 0476e35e6e275db5
---

# VerticalInput

the vertical, or a brand whose vertical is meant

[figure: VerticalInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `vertical` | `id` | no |  |
| `brand` | `id` | no |  |



## Routes that use it
- [`/v1/read/vertical`](/reference/read/vertical) takes it as input


---
title: "Voice"
description: "a platform account or person that speaks for the brand, with its role and its code"
section: concepts
address: /concepts/voice
contract: 0476e35e6e275db5
---

# Voice

a platform account or person that speaks for the brand, with its role and its code

[figure: Voice is a definition at brand scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | brand |
| key | the account or person and the brand |
| store | postgres |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `brand` | `id` | yes |  |
| `speaker` | `id` | yes | an account or a person |
| `role` | `one of own account \| staff \| founder \| paid voice on a code \| affiliate \| teacher \| advocate` | yes |  |
| `code` | `text` | no |  |
| `since` | `time` | yes |  |



## Routes that use it
No route takes or returns Voice directly. The record holds it, and the objects that point at it reach it.


---
title: "WaitingInput"
description: "nothing, or a notification to acknowledge"
section: concepts
address: /concepts/waitinginput
contract: 0476e35e6e275db5
---

# WaitingInput

nothing, or a notification to acknowledge

[figure: WaitingInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `acknowledge` | `id` | no |  |



## Routes that use it
- [`/v1/view/waiting`](/reference/view/waiting) takes it as input


---
title: "WaitingItem"
description: "a unit in a place whose reader is a person"
section: concepts
address: /concepts/waitingitem
contract: 0476e35e6e275db5
---

# WaitingItem

a unit in a place whose reader is a person

[figure: WaitingItem is a view at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | none |
| key | the unit |
| store | derived |
| family | ops_console |



## Fields


| field | type | required | note |
|---|---|---|---|
| `unit` | `id` | yes |  |
| `place` | `text` | yes |  |
| `since` | `time` | yes |  |
| `tool` | `text` | yes | the tool that resolves it |



## Routes that use it
No route takes or returns WaitingItem directly. The record holds it, and the objects that point at it reach it.


---
title: "WatchedIdentity"
description: "a public entity to follow, as an armed monitor over it"
section: concepts
address: /concepts/watchedidentity
contract: 0476e35e6e275db5
---

# WatchedIdentity

a public entity to follow, as an armed monitor over it

[figure: WatchedIdentity is a definition at tenant scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | tenant |
| key | the public entity |
| store | postgres |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `entity` | `id` | yes |  |
| `monitor` | `id` | yes |  |



## Routes that use it
- [`/v1/act/watch`](/reference/act/watch) returns it


---
title: "WatchInput"
description: "a public entity to watch"
section: concepts
address: /concepts/watchinput
contract: 0476e35e6e275db5
---

# WatchInput

a public entity to watch

[figure: WatchInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `entity` | `id` | yes |  |



## Routes that use it
- [`/v1/act/watch`](/reference/act/watch) takes it as input


---
title: "WatchSiteInput"
description: "a site watch to write, preview or arm"
section: concepts
address: /concepts/watchsiteinput
contract: 0476e35e6e275db5
---

# WatchSiteInput

a site watch to write, preview or arm

[figure: WatchSiteInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `watch` | [SiteWatch](/concepts/sitewatch) | yes |  |
| `flow` | `one of write \| preview \| arm \| disarm` | yes |  |



## Routes that use it
- [`/v1/act/watch_site`](/reference/act/watch_site) takes it as input


---
title: "WayContract"
description: "the contract of a way"
section: concepts
address: /concepts/waycontract
contract: 0476e35e6e275db5
---

# WayContract

the contract of a way

[figure: WayContract is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `transport` | `text` | yes | the way's own transport written again, the name of a row of the transports; the way's transport field is the authority, and the register build rejects a contract that names another |
| `unit_of_input` | `text` | yes |  |
| `cursor_kind` | `text` | yes |  |
| `yesterday_is_cheap` | `bool` | yes |  |
| `deletions_visible` | `bool` | yes |  |
| `edits_visible` | `bool` | yes |  |
| `probe` | `text` | no | a cheap probe where one exists |
| `release_rule` | `one of appends \| republishes whole \| publishes its changes` | no | for a source that republishes whole, a row that vanishes is itself the news |



## Routes that use it
No route takes or returns WayContract directly. The record holds it, and the objects that point at it reach it.


---
title: "WayOfGoingToMarket"
description: "how a brand gets buyers, held as rows and never as code"
section: concepts
address: /concepts/wayofgoingtomarket
contract: 0476e35e6e275db5
---

# WayOfGoingToMarket

how a brand gets buyers, held as rows and never as code

[figure: WayOfGoingToMarket is a row at platform scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | row |
| scope | platform |
| key | its name |
| store | postgres |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `where_the_wanting_is` | `text` | yes |  |
| `who_is_sold_to` | `text` | yes |  |
| `who_never_buys_and_still_matters` | [RoleAroundADecision](/concepts/rolearoundadecision) | yes |  |
| `connection_kinds` | [KindOfConnection](/concepts/kindofconnection) | yes |  |
| `ladder` | `id` | yes |  |
| `plays` | `[id]` | yes |  |
| `what_is_counted` | [KindOfMeasure](/concepts/kindofmeasure) | yes |  |
| `kinds_of_action` | [KindOfAction](/concepts/kindofaction) | yes |  |



## Routes that use it
No route takes or returns WayOfGoingToMarket directly. The record holds it, and the objects that point at it reach it.


---
title: "WebhookInput"
description: "an address to be told at, and the kinds"
section: concepts
address: /concepts/webhookinput
contract: 0476e35e6e275db5
---

# WebhookInput

an address to be told at, and the kinds

[figure: WebhookInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `telling` | [Telling](/concepts/telling) | yes |  |



## Routes that use it
- [`/v1/act/webhook`](/reference/act/webhook) takes it as input


---
title: "WeighInput"
description: "a claim and the evidence to attach"
section: concepts
address: /concepts/weighinput
contract: 0476e35e6e275db5
---

# WeighInput

a claim and the evidence to attach

[figure: WeighInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `hypothesis` | `id` | yes |  |
| `for` | [EvidenceRef](/concepts/evidenceref) | no |  |
| `against` | [EvidenceRef](/concepts/evidenceref) | no |  |



## Routes that use it
- [`/v1/act/weigh`](/reference/act/weigh) takes it as input


---
title: "WhatChanged"
description: "every number that moved, with its unit, and every figure replaced"
section: concepts
address: /concepts/whatchanged
contract: 0476e35e6e275db5
---

# WhatChanged

every number that moved, with its unit, and every figure replaced

[figure: WhatChanged is a view at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | none |
| key | two builds of one document |
| store | derived |
| family | documents |



## Fields


| field | type | required | note |
|---|---|---|---|
| `first` | `id` | yes |  |
| `second` | `id` | yes |  |
| `moved` | [NumberChange](/concepts/numberchange) | yes |  |
| `figures_replaced` | `[text]` | yes |  |



## Routes that use it
- [`/v1/read/document_changes`](/reference/read/document_changes) returns it


---
title: "WhoAmIInput"
description: "a token, a key, or a run's identity"
section: concepts
address: /concepts/whoamiinput
contract: 0476e35e6e275db5
---

# WhoAmIInput

a token, a key, or a run's identity

[figure: WhoAmIInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `token` | `text` | no | never logged |
| `key` | `id` | no |  |
| `run` | `id` | no |  |



## Routes that use it
- [`/v1/session/whoami`](/reference/session/whoami) takes it as input


---
title: "WhyAnswer"
description: "the chain of reasons, from this unit back to its first cause"
section: concepts
address: /concepts/whyanswer
contract: 0476e35e6e275db5
---

# WhyAnswer

the chain of reasons, from this unit back to its first cause

[figure: WhyAnswer is a view at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `reasons` | [Reason](/concepts/reason) | yes |  |



## Routes that use it
- [`/v1/read/why`](/reference/read/why) returns it


---
title: "WhyInput"
description: "a unit that is not ready, or a count that is not measured"
section: concepts
address: /concepts/whyinput
contract: 0476e35e6e275db5
---

# WhyInput

a unit that is not ready, or a count that is not measured

[figure: WhyInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `unit` | [UnitRef](/concepts/unitref) | yes |  |



## Routes that use it
- [`/v1/read/why`](/reference/read/why) takes it as input


---
title: "Window"
description: "a window at both ends"
section: concepts
address: /concepts/window
contract: 0476e35e6e275db5
---

# Window

a window at both ends

[figure: Window is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | identity |



## Fields


| field | type | required | note |
|---|---|---|---|
| `from` | `time` | yes |  |
| `to` | `time` | yes |  |



## Routes that use it
No route takes or returns Window directly. The record holds it, and the objects that point at it reach it.


---
title: "WithdrawInput"
description: "a publishing to withdraw"
section: concepts
address: /concepts/withdrawinput
contract: 0476e35e6e275db5
---

# WithdrawInput

a publishing to withdraw

[figure: WithdrawInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `publishing` | `id` | yes |  |
| `reason` | `text` | yes |  |



## Routes that use it
- [`/v1/act/withdraw`](/reference/act/withdraw) takes it as input


---
title: "WithheldCount"
description: "the leads that exist and the plan does not yet deliver, by kind of buyer and temperature; never who"
section: concepts
address: /concepts/withheldcount
contract: 0476e35e6e275db5
---

# WithheldCount

the leads that exist and the plan does not yet deliver, by kind of buyer and temperature; never who

[figure: WithheldCount is a view at brand scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | brand |
| key | the brand, the period |
| store | derived |
| family | leads |



## Fields


| field | type | required | note |
|---|---|---|---|
| `brand` | `id` | yes |  |
| `period` | [Window](/concepts/window) | yes |  |
| `by_kind` | `{text:count}` | yes |  |
| `by_temperature` | `{text:count}` | yes |  |
| `limit` | `count` | yes |  |
| `reference` | `text` | no | how to reproduce the count from the one log: the flow, the positions from and to, and the rule that a unit counts when its last event in the period withheld it |



## Routes that use it
- [`/v1/read/withheld`](/reference/read/withheld) returns it


---
title: "WithheldInput"
description: "a brand or a tenant, and the period"
section: concepts
address: /concepts/withheldinput
contract: 0476e35e6e275db5
---

# WithheldInput

a brand or a tenant, and the period

[figure: WithheldInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `brand` | `id` | no |  |
| `tenant` | `id` | no |  |
| `period` | [Window](/concepts/window) | yes |  |



## Routes that use it
- [`/v1/read/withheld`](/reference/read/withheld) takes it as input


---
title: "WithheldReason"
description: "why a lead is withheld: the limit reached, with the count reproducible from the record"
section: concepts
address: /concepts/withheldreason
contract: 0476e35e6e275db5
---

# WithheldReason

why a lead is withheld: the limit reached, with the count reproducible from the record

[figure: WithheldReason is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | leads |



## Fields


| field | type | required | note |
|---|---|---|---|
| `limit` | `count` | yes |  |
| `period` | `duration` | yes |  |
| `count_in_period` | `count` | yes |  |
| `since` | `time` | yes |  |



## Routes that use it
No route takes or returns WithheldReason directly. The record holds it, and the objects that point at it reach it.


---
title: "Word"
description: "one of the market's own words, with its meaning"
section: concepts
address: /concepts/word
contract: 0476e35e6e275db5
---

# Word

one of the market's own words, with its meaning

[figure: Word is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | market |



## Fields


| field | type | required | note |
|---|---|---|---|
| `term` | `text` | yes |  |
| `means` | `text` | yes |  |



## Routes that use it
No route takes or returns Word directly. The record holds it, and the objects that point at it reach it.


---
title: "WorkBase"
description: "what every unit of work carries beyond the unit"
section: concepts
address: /concepts/workbase
contract: 0476e35e6e275db5
---

# WorkBase

what every unit of work carries beyond the unit

[figure: WorkBase is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | carried by every unit of work |
| store | none |
| family | kernel |



## Fields


| field | type | required | note |
|---|---|---|---|
| `place` | `text` | yes | exactly one of the kind's places |
| `entered_place_at` | `time` | yes |  |
| `due_at` | `time` | no | its deadline |
| `held_reason` | `text` | no | required whenever it waits |
| `input_key` | `text` | yes | its idempotency key, so the same input is the same work |
| `attempts` | [Attempt](/concepts/attempt) | yes | each with the class of its failure |
| `cost` | [Cost](/concepts/cost) | yes |  |



## Routes that use it
No route takes or returns WorkBase directly. The record holds it, and the objects that point at it reach it.


---
title: "Workbench"
description: "a place to run queries, and later code, over what the caller may read, through the tools"
section: concepts
address: /concepts/workbench
contract: 0476e35e6e275db5
---

# Workbench

a place to run queries, and later code, over what the caller may read, through the tools

[figure: Workbench is a definition at strategy scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | strategy |
| key | the strategy |
| store | postgres |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `strategy` | `id` | yes |  |
| `allows_code` | `bool` | yes |  |
| `time_budget` | `duration` | yes |  |



## Routes that use it
No route takes or returns Workbench directly. The record holds it, and the objects that point at it reach it.


---
title: "Workflow"
description: "steps and what starts them, the same object whether a person or the agent composed it"
section: concepts
address: /concepts/workflow
contract: 0476e35e6e275db5
---

# Workflow

steps and what starts them, the same object whether a person or the agent composed it

[figure: Workflow is a definition at strategy scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | definition |
| scope | strategy |
| key | its name and version |
| store | postgres |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `starts_on` | `one of a match \| a beat \| a flow \| a person's word` | yes |  |
| `start_ref` | `id` | no |  |
| `steps` | [WorkflowStep](/concepts/workflowstep) | yes |  |
| `strategy` | `id` | yes |  |
| `state` | [Readiness](/concepts/readiness) | yes | ready only when every tool it names is ready |



## Routes that use it
No route takes or returns Workflow directly. The record holds it, and the objects that point at it reach it.


---
title: "WorkflowAnswer"
description: "the workflow, and for a preview what it would have done over history"
section: concepts
address: /concepts/workflowanswer
contract: 0476e35e6e275db5
---

# WorkflowAnswer

the workflow, and for a preview what it would have done over history

[figure: WorkflowAnswer is a view at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `workflow` | [Workflow](/concepts/workflow) | yes |  |
| `would_have_done` | [StepResult](/concepts/stepresult) | no |  |



## Routes that use it
- [`/v1/act/workflow`](/reference/act/workflow) returns it


---
title: "WorkflowInput"
description: "a workflow to write, preview or arm"
section: concepts
address: /concepts/workflowinput
contract: 0476e35e6e275db5
---

# WorkflowInput

a workflow to write, preview or arm

[figure: WorkflowInput is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `workflow` | [Workflow](/concepts/workflow) | yes |  |
| `do` | `one of write \| preview \| arm` | yes |  |



## Routes that use it
- [`/v1/act/workflow`](/reference/act/workflow) takes it as input


---
title: "WorkflowStep"
description: "one step: a tool to run, a wait, a branch on a predicate, or another workflow"
section: concepts
address: /concepts/workflowstep
contract: 0476e35e6e275db5
---

# WorkflowStep

one step: a tool to run, a wait, a branch on a predicate, or another workflow

[figure: WorkflowStep is a value at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | value |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `kind` | `one of tool \| wait \| branch \| workflow \| work` | yes | work is a kind of platform work the platform runs itself, such as the backup, named by its kind row |
| `tool` | `text` | no |  |
| `input` | `json` | no | the serialisation of the tool's input type |
| `work` | [Kind](/concepts/kind) | no | for a work step, the kind of platform work it runs; a kind with no runner in the release makes the workflow not ready |
| `wait` | `duration` | no |  |
| `on_wait_passed` | `text` | no |  |
| `branch` | `hash` | no | a predicate |
| `workflow` | `id` | no |  |



## Routes that use it
No route takes or returns WorkflowStep directly. The record holds it, and the objects that point at it reach it.


---
title: "Workspace"
description: "the workspace folder, and every act the app made in it on the ledger"
section: concepts
address: /concepts/workspace
contract: 0476e35e6e275db5
---

# Workspace

the workspace folder, and every act the app made in it on the ledger

[figure: Workspace is a view at none scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | view |
| scope | none |
| key | none |
| store | none |
| family | harness |



## Fields


| field | type | required | note |
|---|---|---|---|
| `folder` | `text` | yes |  |
| `acts` | [Event](/concepts/event) | yes |  |



## Routes that use it
- [`/v1/files/workspace`](/reference/files/workspace) returns it


---
title: "Yield"
description: "what a job returned for each unit of cost, with the host's measured rate and health"
section: concepts
address: /concepts/yield
contract: 0476e35e6e275db5
---

# Yield

what a job returned for each unit of cost, with the host's measured rate and health

[figure: Yield is a fact at follows scope. The drawing shows its fields and the objects that they point at.]

| property | value |
|---|---|
| kind | fact |
| scope | follows |
| key | the job |
| store | postgres+lake |
| family | sources |



## Fields


| field | type | required | note |
|---|---|---|---|
| `job` | `id` | yes |  |
| `units_returned` | `count` | yes |  |
| `cost` | [Cost](/concepts/cost) | yes |  |
| `rate_measured` | `count` | yes |  |
| `health` | `one of good \| degraded \| down` | yes |  |



## Routes that use it
No route takes or returns Yield directly. The record holds it, and the objects that point at it reach it.


---
title: "The systems"
description: "One page per system of the platform: its calls on the wire, and the bars it enforces, at contract 0476e35e6e275db5."
section: systems
address: /systems
contract: 0476e35e6e275db5
---

# The systems

One page per system of the platform: its calls on the wire, and the bars it enforces, at contract 0476e35e6e275db5.

[figure: 21 systems of the platform, each with its calls on the wire.]

# The systems

Each page below is one system of the platform as the contract serves it: every route and every tool the system's specification names, and the bars its parameter rows enforce. The pages are generated from the API document and the MCP manifest, which carry on every operation and tool the specification it serves.

| system | calls |
|---|---|
| [The kernel](/systems/01-the-kernel) | 7 |
| [The registers, and the contract crate](/systems/02-the-registers-and-the-contract-crate) | 2 |
| [People, scope and rights](/systems/03-people-scope-and-rights) | 13 |
| [The record](/systems/04-the-record) | 6 |
| [Identity resolution](/systems/05-identity-resolution) | 4 |
| [The rules engine](/systems/06-the-rules-engine) | 16 |
| [Sources and acquisition](/systems/07-sources-and-acquisition) | 6 |
| [Leads and the team](/systems/08-leads-and-the-team) | 11 |
| [The harness](/systems/09-the-harness) | 8 |
| [The API gateway](/systems/10-the-api-gateway) | 2 |
| [The ops console](/systems/11-the-ops-console) | 9 |
| [The market as it is held](/systems/12-the-market-as-it-is-held) | 18 |
| [Strategy, action and learning](/systems/13-strategy-action-and-learning) | 18 |
| [Models and intelligence](/systems/14-models-and-intelligence) | 4 |
| [Documents from the record](/systems/17-documents-from-the-record) | 5 |
| [The acquisition system and the connector standard](/systems/18-the-acquisition-system-and-the-connector-standard) | 28 |
| [Operations, security and observability](/systems/19-operations-security-and-observability) | 4 |
| [The capture extension: a person's own browser as a capture surface](/systems/24-the-capture-extension-a-person-s-own-browser-as-a-capture-surface) | 7 |
| [The economics of the market: business models, benchmarks, the return to a buyer, and prices](/systems/25-the-economics-of-the-market-business-models-benchmarks-the-return-to-a-buyer-and-prices) | 6 |
| [The market as a living system: value chains, systems models, templates and the search for product-market fit](/systems/26-the-market-as-a-living-system-value-chains-systems-models-templates-and-the-search-for-product-market-fit) | 13 |
| [specification app](/systems/app-specification-app) | 8 |


---
title: "The kernel"
description: "The kernel: the 7 calls this system serves, each a route of the API and a tool of the MCP server, at contract 0476e35e6e275db5."
section: systems
address: /systems/01-the-kernel
contract: 0476e35e6e275db5
---

# The kernel

The kernel: the 7 calls this system serves, each a route of the API and a tool of the MCP server, at contract 0476e35e6e275db5.

[figure: The kernel: 7 calls of the contract, by family.]

# The kernel

The 7 calls below are the whole of this system on the wire: each is one route of the API and one tool of the MCP server, with one typed input, one card as its answer and one refusal shape. Every answer carries its foot: what was read, the population and the control.

## The calls



| tool | route | takes | gives |
|---|---|---|---|
| [si.read.parameter](/reference/tools/si-read-parameter) | [POST /v1/read/parameter](/reference/read/parameter) | its name | its value, with its dimension and version |
| [si.read.under_test](/reference/tools/si-read-under_test) | [POST /v1/read/under_test](/reference/read/under_test) | a subject or a scope, and the two dates | every hypothesis about it with its standing, its evidence for and against, the tests run and the tests owed, and what would settle each |
| [si.read.unit](/reference/tools/si-read-unit) | [POST /v1/read/unit](/reference/read/unit) | the kind, the id, the caller | the unit |
| [si.act.correct](/reference/tools/si-act-correct) | [POST /v1/act/correct](/reference/act/correct) | the id of the wrong event, and the right facts | a correcting event |
| [si.act.parameter](/reference/tools/si-act-parameter) | [POST /v1/act/parameter](/reference/act/parameter) | a parameter by its name, its value and its scope | the parameter as written, at its new version |
| [si.act.settle](/reference/tools/si-act-settle) | [POST /v1/act/settle](/reference/act/settle) | a hypothesis, the standing, the caller | the hypothesis settled, with who settled it and on what |
| [si.act.weigh](/reference/tools/si-act-weigh) | [POST /v1/act/weigh](/reference/act/weigh) | a hypothesis, and a fact or a test's reading | the hypothesis with the evidence attached and its standing recomputed against its bar |



## The bars this system enforces

Every bar is a row of the parameter register: an administrator changes it, and the platform reads it by name at the place of enforcement the row records.

| parameter | family | dimension | enforced at |
|---|---|---|---|
| the longest wait of each place of a kind | machinery | a time for each place | the place's reader, and the ops console that counts units past it |
| the time within which a move of a unit ends | machinery | a time | the kernel's move, measured at the first build stage and then fixed |


---
title: "The registers, and the contract crate"
description: "The registers, and the contract crate: the 2 calls this system serves, each a route of the API and a tool of the MCP server, at contract 0476e35e6e275db5."
section: systems
address: /systems/02-the-registers-and-the-contract-crate
contract: 0476e35e6e275db5
---

# The registers, and the contract crate

The registers, and the contract crate: the 2 calls this system serves, each a route of the API and a tool of the MCP server, at contract 0476e35e6e275db5.

[figure: The registers, and the contract crate: 2 calls of the contract, by family.]

# The registers, and the contract crate

The 2 calls below are the whole of this system on the wire: each is one route of the API and one tool of the MCP server, with one typed input, one card as its answer and one refusal shape. Every answer carries its foot: what was read, the population and the control.

## The calls



| tool | route | takes | gives |
|---|---|---|---|
| [si.read.register](/reference/tools/si-read-register) | [POST /v1/read/register](/reference/read/register) | its name, and a version or *current* | its rows, and the hash |
| [si.read.registered](/reference/tools/si-read-registered) | [POST /v1/read/registered](/reference/read/registered) | a register and a name | the row, or nothing |


---
title: "People, scope and rights"
description: "People, scope and rights: the 13 calls this system serves, each a route of the API and a tool of the MCP server, at contract 0476e35e6e275db5."
section: systems
address: /systems/03-people-scope-and-rights
contract: 0476e35e6e275db5
---

# People, scope and rights

People, scope and rights: the 13 calls this system serves, each a route of the API and a tool of the MCP server, at contract 0476e35e6e275db5.

[figure: People, scope and rights: 13 calls of the contract, by family.]

# People, scope and rights

The 13 calls below are the whole of this system on the wire: each is one route of the API and one tool of the MCP server, with one typed input, one card as its answer and one refusal shape. Every answer carries its foot: what was read, the population and the control.

## The calls



| tool | route | takes | gives |
|---|---|---|---|
| [si.session.my_grants](/reference/tools/si-session-my_grants) | [POST /v1/session/my_grants](/reference/session/my_grants) | the caller, and a place | its permissions there, after all three narrowings |
| [si.session.my_scopes](/reference/tools/si-session-my_scopes) | [POST /v1/session/my_scopes](/reference/session/my_scopes) | the caller | the scopes it reads, set on the database transaction before any query runs |
| [si.session.sign_out](/reference/tools/si-session-sign_out) | [POST /v1/session/sign_out](/reference/session/sign_out) | the session or the user | nothing |
| [si.session.whoami](/reference/tools/si-session-whoami) | [POST /v1/session/whoami](/reference/session/whoami) | a token, a key, or a run's identity | the caller, with its scopes and its access scopes |
| [si.read.consent](/reference/tools/si-read-consent) | [POST /v1/read/consent](/reference/read/consent) | the person or tenant, and the use | a fact. Or yes or no, with the fact that decides |
| [si.read.invitations](/reference/tools/si-read-invitations) | [POST /v1/read/invitations](/reference/read/invitations) | nothing | the invitations with their states |
| [si.read.receipts](/reference/tools/si-read-receipts) | [POST /v1/read/receipts](/reference/read/receipts) | the kind, export or erasure | the receipts |
| [si.act.erase_person](/reference/tools/si-act-erase_person) | [POST /v1/act/erase_person](/reference/act/erase_person) | the person | the erasure as work, then its receipt |
| [si.act.export_tenant](/reference/tools/si-act-export_tenant) | [POST /v1/act/export_tenant](/reference/act/export_tenant) | nothing | the export as work, then its receipt |
| [si.act.grant](/reference/tools/si-act-grant) | [POST /v1/act/grant](/reference/act/grant) | the grant, by a caller who may give it | the grant's new version |
| [si.act.invite](/reference/tools/si-act-invite) | [POST /v1/act/invite](/reference/act/invite) | an address and a role | the invitation, open, with its expiry |
| [si.act.membership](/reference/tools/si-act-membership) | [POST /v1/act/membership](/reference/act/membership) | the person's address, and the roles with where each is held | the membership |
| [si.act.sign_up](/reference/tools/si-act-sign_up) | [POST /v1/act/sign_up](/reference/act/sign_up) | the company's name, and its domain where known, from a signed-in person who belongs to no tenant | the tenant, made on the trial plan with the person as its first member and owner, in one transaction with its events |



## The bars this system enforces

Every bar is a row of the parameter register: an administrator changes it, and the platform reads it by name at the place of enforcement the row records.

| parameter | family | dimension | enforced at |
|---|---|---|---|
| the longest life of a token | machinery | a time | the API gateway's short list of ended tokens, which is never longer than it |
| the interval between fetches of a provider's keys | machinery | a time | the API gateway |
| a grant's limits: its budget by kind, its rate and its end date | receive | units of a kind; calls in a time; a date | the single authorization check before any action |
| the longest wait of a removal request | machinery | a time | the removal's reader, which notifies a user past it |


---
title: "The record"
description: "The record: the 6 calls this system serves, each a route of the API and a tool of the MCP server, at contract 0476e35e6e275db5."
section: systems
address: /systems/04-the-record
contract: 0476e35e6e275db5
---

# The record

The record: the 6 calls this system serves, each a route of the API and a tool of the MCP server, at contract 0476e35e6e275db5.

[figure: The record: 6 calls of the contract, by family.]

# The record

The 6 calls below are the whole of this system on the wire: each is one route of the API and one tool of the MCP server, with one typed input, one card as its answer and one refusal shape. Every answer carries its foot: what was read, the population and the control.

## The calls



| tool | route | takes | gives |
|---|---|---|---|
| [si.ask.facts](/reference/tools/si-ask-facts) | [POST /v1/ask/facts](/reference/ask/facts) | a unit or a population, the date it was true, and the date we knew it, as two parameters. Both default to now | the facts, and the tier that gave them |
| [si.ask.groups](/reference/tools/si-ask-groups) | [POST /v1/ask/groups](/reference/ask/groups) | a scope, the two dates, and the resolution of the cut | the cluster response cards: each group with the share each layer of likeness contributed, its top communities, words and domains, its size and trend by month, and the proxies that placed its members |
| [si.ask.neighbours](/reference/tools/si-ask-neighbours) | [POST /v1/ask/neighbours](/reference/ask/neighbours) | an entity, one kind of connection, and the two dates | the members, one hop away, and whether the cap was reached |
| [si.ask.semantic_search](/reference/tools/si-ask-semantic_search) | [POST /v1/ask/semantic_search](/reference/ask/semantic_search) | a text or a subject's vector, the model, a floor and a population | the units above the floor. With them: the model, the floor, the measured recall of quantized embeddings, and the tier |
| [si.read.why](/reference/tools/si-read-why) | [POST /v1/read/why](/reference/read/why) | any unit | the chain of reasons, from this unit back to its first cause |
| [si.act.deepen](/reference/tools/si-act-deepen) | [POST /v1/act/deepen](/reference/act/deepen) | an observation, and the depth: fetched in full, or given meaning | a deepening |



## The bars this system enforces

Every bar is a row of the parameter register: an administrator changes it, and the platform reads it by name at the place of enforcement the row records.

| parameter | family | dimension | enforced at |
|---|---|---|---|
| the rows a landing of observations takes per beat: the newest rows of the texts table not yet landed, so the landing grows with its source one beat at a time | machinery | a count (20,000 as stipulated) | the beat that lands the observations |
| when an open partition closes: the longest age of its oldest open row, and the most rows it may hold, whichever comes first | machinery | a time, and a count of rows | close a partition, by the host that writes it. This rule sets the seconds from a source's read to a first result. First values from the reading of 22 September (test 20): one hour and 300,000 rows |
| the target size of a closed partition's file, the floor under which no file is left in a closed partition, and the beat on which a closed partition is tidied to one file | machinery | bytes; bytes; an event | the tidier, when a partition closes. First values from the reading of 22 September (test 20): 128 megabytes, 1 megabyte, tidy when the partition closes, and a day's grain for both tables; a tidy removes the files it replaced, since a file left behind serves one engine and not another |
| the longest wait of each place of a deepening, and of a fill of meaning | machinery | a time | the reader of that place |
| the cap on the neighbours one entity may bring to an answer | machinery | a count of members | the read of neighbours |
| the recall of quantized embeddings against the wide, for each pair of models | machinery | a share | the semantic search. Measured before the tier is used, and again when either model changes |
| the age behind which the database may be pruned | machinery | a time | the pruner, and never ahead of the gold layer |
| the address of the lakehouse's store | machinery | an address | the record's writer and every reader. On a laptop it is a folder, which the lakehouse's format reads and writes as files with the same catalogue rows; on the three machines it is the bucket; the same scripts run against both |
| the layout of a table keyed by an entity: the count of buckets a plane splits it into | machinery | a count for each plane | the writer when a partition closes, and the tidier. First values, stipulated until the reading of : 256 on the shared plane, 16 on the tenant's plane, 16 on the platform's plane |
| the coarse index of meaning: the count of centroids for each model, the count of centroids a search probes, and the width of the sketch | machinery | counts; bits | the fill of meaning, which assigns the centroid, and the semantic search. First values, stipulated until the reading of : 65,536 centroids on the shared plane and 256 on the tenant's plane, 32 probed, 64 bits |
| the recent window the database holds whole, for the instant speed: a time and a list of kinds for each plane | machinery | a time; a list of kinds | the working set's writer and the instant preview, whose population statement names it. First values stipulated: seven days of silver's rows for the tenant's plane and the platform's plane; one day of the kinds armed monitors name for the shared plane |
| the fewest tenants a total across tenants may be made from | machinery | a count | the build of a served table on the platform's plane. First value stipulated: 5 |


---
title: "Identity resolution"
description: "Identity resolution: the 4 calls this system serves, each a route of the API and a tool of the MCP server, at contract 0476e35e6e275db5."
section: systems
address: /systems/05-identity-resolution
contract: 0476e35e6e275db5
---

# Identity resolution

Identity resolution: the 4 calls this system serves, each a route of the API and a tool of the MCP server, at contract 0476e35e6e275db5.

[figure: Identity resolution: 4 calls of the contract, by family.]

# Identity resolution

The 4 calls below are the whole of this system on the wire: each is one route of the API and one tool of the MCP server, with one typed input, one card as its answer and one refusal shape. Every answer carries its foot: what was read, the population and the control.

## The calls



| tool | route | takes | gives |
|---|---|---|---|
| [si.read.entity](/reference/tools/si-read-entity) | [POST /v1/read/entity](/reference/read/entity) | an entity, and the two dates | every identifier it ever had, every account, everything it published, every thread, community and gathering, and every connection, across platforms and sources |
| [si.read.lookup](/reference/tools/si-read-lookup) | [POST /v1/read/lookup](/reference/read/lookup) | a key: a namespace with a value, or a name with a place, and with a name a breadth. And the two dates | the entity, or the possible matches, or nothing; with a breadth, the record's candidates by the one candidate search |
| [si.act.settle_match](/reference/tools/si-act-settle_match) | [POST /v1/act/settle_match](/reference/act/settle_match) | the possible match, and a user's answer or a proof | confirmed, with the merge. Or rejected |
| [si.act.undo_merge](/reference/tools/si-act-undo_merge) | [POST /v1/act/undo_merge](/reference/act/undo_merge) | the merge or the decision, and the reason | a parting. Or a later decision, with the facts written again |



## The bars this system enforces

Every bar is a row of the parameter register: an administrator changes it, and the platform reads it by name at the place of enforcement the row records.

| parameter | family | dimension | enforced at |
|---|---|---|---|
| the trust of each identifier namespace, for each kind | machinery | a rank | decide identity, at the step that keys a mention |
| the values shared by design, which are never keys | machinery | a list | the same step |
| the limit on how often a namespace's values may be shared before it may no longer decide | machinery | a share | the same step, read from the fitness of the key |
| the cap on how many entities one shared value may bring in | machinery | a count of entities | decide identity, at the step that brings candidates in |
| the upper and the lower bar, for each kind | machinery | a chance | decide identity, at the step that decides. |
| the smallest gap between the first and second candidate below which the machine may not decide | machinery | a chance | decide identity, at the step that decides |
| the labelled pairs a method needs before it is ready | machinery | a count of pairs | making a method ready |
| the longest wait of a possible match | machinery | a time | the reader of the place *waiting* |
| the size of the audit's sample, and its beat | machinery | a count, and a time | audit identity |


---
title: "The rules engine"
description: "The rules engine: the 16 calls this system serves, each a route of the API and a tool of the MCP server, at contract 0476e35e6e275db5."
section: systems
address: /systems/06-the-rules-engine
contract: 0476e35e6e275db5
---

# The rules engine

The rules engine: the 16 calls this system serves, each a route of the API and a tool of the MCP server, at contract 0476e35e6e275db5.

[figure: The rules engine: 16 calls of the contract, by family.]

# The rules engine

The 16 calls below are the whole of this system on the wire: each is one route of the API and one tool of the MCP server, with one typed input, one card as its answer and one refusal shape. Every answer carries its foot: what was read, the population and the control.

## The calls



| tool | route | takes | gives |
|---|---|---|---|
| [si.ask.preview](/reference/tools/si-ask-preview) | [POST /v1/ask/preview](/reference/ask/preview) | a predicate or its hash, the place, the window, the speeds wanted, and the caller with the surface it calls from | the typed answer of section 2.3, as it fills |
| [si.ask.saved_view](/reference/tools/si-ask-saved_view) | [POST /v1/ask/saved_view](/reference/ask/saved_view) | the view. Or the view and a caller | the definition. Or its rows, with when they were built |
| [si.read.attributes](/reference/tools/si-read-attributes) | [POST /v1/read/attributes](/reference/read/attributes) | a population and, where wanted, a window | the attributes its units carry, each with its plain name, the units that carry it, the value type read and up to three examples, most carried first, with the units read and in, and the partial answer when the budget ran out |
| [si.read.basket](/reference/tools/si-read-basket) | [POST /v1/read/basket](/reference/read/basket) | the basket, and one subject, a set of subjects, a scope predicate or a cut into groups, with the window | the basket reading as a fact: memberships with their scale of association and likelihood for one subject; population readings and co-membership for a set; proxy against group with lift and control for groups |
| [si.read.explain_catch](/reference/tools/si-read-explain_catch) | [POST /v1/read/explain_catch](/reference/read/explain_catch) | the match | the conditions that admitted it, the words each matched, the observation, and the source |
| [si.read.monitor_strength](/reference/tools/si-read-monitor_strength) | [POST /v1/read/monitor_strength](/reference/read/monitor_strength) | the monitor and a window | the four numbers, each with its population |
| [si.read.predicate_language](/reference/tools/si-read-predicate_language) | [POST /v1/read/predicate_language](/reference/read/predicate_language) | the register's name | its rows with the hash |
| [si.read.proxy](/reference/tools/si-read-proxy) | [POST /v1/read/proxy](/reference/read/proxy) | the proxy and its version, the two dates, and a place | its members as a population, with the raw count, the estimate corrected by the recall and the undercount's interval, its calibration by segment, its coverage by channel, and its co-membership with other proxies; for an aggregate-only proxy the counts alone and never a member |
| [si.read.signals](/reference/tools/si-read-signals) | [POST /v1/read/signals](/reference/read/signals) | a monitor, a subject, a kind or a strategy, and a window | the facts, with the coverage and the count not evaluable for the same window |
| [si.act.arm_monitor](/reference/tools/si-act-arm_monitor) | [POST /v1/act/arm_monitor](/reference/act/arm_monitor) | the monitor's version, and for arming the preview it was judged by | the monitor's new state |
| [si.act.keep_basket](/reference/tools/si-act-keep_basket) | [POST /v1/act/keep_basket](/reference/act/keep_basket) | its name, its scope and its proxies by version | the basket with its version, not ready while any proxy is |
| [si.act.keep_ladder](/reference/tools/si-act-keep_ladder) | [POST /v1/act/keep_ladder](/reference/act/keep_ladder) | its ordered rungs, each a predicate over the population, and the rung that qualifies; the rungs' predicates in full where they are not yet kept | the ladder with its version, not ready while a rung's predicate is not kept or does not compile |
| [si.act.keep_monitor](/reference/tools/si-act-keep_monitor) | [POST /v1/act/keep_monitor](/reference/act/keep_monitor) | its name, its predicate, the place it runs at, the kind of signal it makes, the strategy where one is chosen, and for a platform monitor the vertical | the monitor with its version, not armed; not ready while its predicate does not compile at its place, with the reasons from compile |
| [si.act.keep_proxy](/reference/tools/si-act-keep_proxy) | [POST /v1/act/keep_proxy](/reference/act/keep_proxy) | a proxy: its name, the facet kind it stands for, its scope, its rule as a predicate, its strength, its named control, its failure mode, and whether it is aggregate-only | the proxy with its version by hash, not ready until its controls have run and its calibration is read |
| [si.work.build_facet](/reference/tools/si-work-build_facet) | [POST /v1/work/build_facet](/reference/work/build_facet) | a facet kind, a seed (a predicate, a list of communities, or a place from the gazetteer), the scope, and the positive and negative controls | the facet's register with every candidate kept or dropped and its reason in words, its people, its pairs and its trend, and the facet not ready until its calibration is read |
| [si.work.cancel](/reference/tools/si-work-cancel) | [POST /v1/work/cancel](/reference/work/cancel) | the preview | nothing |



## The bars this system enforces

Every bar is a row of the parameter register: an administrator changes it, and the platform reads it by name at the place of enforcement the row records.

| parameter | family | dimension | enforced at |
|---|---|---|---|
| the budgets of a predicate: how far it may expand, how much state it may keep, how large it may be, and how many semantic leaves a tenant may have armed | machinery | counts | compile |
| the shares of the population a breadth admits: the share of the units, ranked by nearness to a probe, that the meaning bar of each breadth lets through, from which the measurement of the bars sets the bar under the served model | machinery | a share per breadth (exact 0.001, similar 0.01, related 0.03, broad 0.1 as stipulated) | the measurement of the bars of nearness, on its beat, which writes the parameter row with the model, the time and the basis |
| the budget of each speed of the preview: units and time | machinery | a count of units; a time | the preview, for each speed |
| the bounds of a statement through the SQL path: rows returned, time and memory | machinery | a count; a time; bytes | the SQL path, on every statement |
| the beat's budget: the units a tick may evaluate, and the definitions it may start | machinery | counts | the beat that runs the monitors and walks the rungs, which serves the definitions oldest first, one tenant after another, and leaves the rest for the next tick |


---
title: "Sources and acquisition"
description: "Sources and acquisition: the 6 calls this system serves, each a route of the API and a tool of the MCP server, at contract 0476e35e6e275db5."
section: systems
address: /systems/07-sources-and-acquisition
contract: 0476e35e6e275db5
---

# Sources and acquisition

Sources and acquisition: the 6 calls this system serves, each a route of the API and a tool of the MCP server, at contract 0476e35e6e275db5.

[figure: Sources and acquisition: 6 calls of the contract, by family.]

# Sources and acquisition

The 6 calls below are the whole of this system on the wire: each is one route of the API and one tool of the MCP server, with one typed input, one card as its answer and one refusal shape. Every answer carries its foot: what was read, the population and the control.

## The calls



| tool | route | takes | gives |
|---|---|---|---|
| [si.read.connectors](/reference/tools/si-read-connectors) | [POST /v1/read/connectors](/reference/read/connectors) | a tenant or a brand | every kind of reading and of action, by source, with its state, the identity it needs, its cost and its rights |
| [si.read.coverage](/reference/tools/si-read-coverage) | [POST /v1/read/coverage](/reference/read/coverage) | a cell, or a scope of entities with a window | what has been read, when and how deep, in the three positions |
| [si.act.decide_ask](/reference/tools/si-act-decide_ask) | [POST /v1/act/decide_ask](/reference/act/decide_ask) | the ask, by a user who may | the ask, approved or declined |
| [si.act.install_connector](/reference/tools/si-act-install_connector) | [POST /v1/act/install_connector](/reference/act/install_connector) | the connector, the ways chosen, and the identity for each | an installed connector, ready or not ready with its reason |
| [si.act.raise_need](/reference/tools/si-act-raise_need) | [POST /v1/act/raise_need](/reference/act/raise_need) | a cell's key, the reason and the value | the cell, wanted |
| [si.act.watch](/reference/tools/si-act-watch) | [POST /v1/act/watch](/reference/act/watch) | a public entity | a watched identity, with its monitor armed |



## The bars this system enforces

Every bar is a row of the parameter register: an administrator changes it, and the platform reads it by name at the place of enforcement the row records.

| parameter | family | dimension | enforced at |
|---|---|---|---|
| the plan's limit of delivered leads | receive | leads in a period | F11's second step, which the register calls *withhold, deliver* |
| the budget of a plan | intend | units of a named kind in a period | F2 |
| the ceiling of risk for an ask | intend | a share | F2b |
| the floor of tenants that must share a need | intend | a count of tenants | F1b |
| depth, rate and politeness of a way | source | items in a call, calls in a time | F4, at the call |
| the byte budget of a connector | source | bytes in a day | F4 |
| the rate for one site, which a lease carries | source | calls in a time, for one way of reaching one address as one identity | F4, at the call, in whichever host holds the lease |
| the acquisition system's declared capacity | machinery | windows in flight | F4, when a job leaves the queue |
| the floor of a cell's coverage | intend | a share of the cell's scope of entities | F7 |
| the retry bound of a partition handover | machinery | a count of tries | F7 |
| the term of a demand statement | machinery | a time | the host, which stops reading under a statement whose term has passed |
| the planning beat | machinery | a time | F2 |
| the longest wait of each place | machinery | a time | the reader of that place |
| the good-for time of each kind of fact | machinery | a time | F1b |
| the order of fetching | intend | a ranking by value | F8a |
| the cadence the platform asks of the acquisition system for a source | intend | a time | F3 |


---
title: "Leads and the team"
description: "Leads and the team: the 11 calls this system serves, each a route of the API and a tool of the MCP server, at contract 0476e35e6e275db5."
section: systems
address: /systems/08-leads-and-the-team
contract: 0476e35e6e275db5
---

# Leads and the team

Leads and the team: the 11 calls this system serves, each a route of the API and a tool of the MCP server, at contract 0476e35e6e275db5.

[figure: Leads and the team: 11 calls of the contract, by family.]

# Leads and the team

The 11 calls below are the whole of this system on the wire: each is one route of the API and one tool of the MCP server, with one typed input, one card as its answer and one refusal shape. Every answer carries its foot: what was read, the population and the control.

## The calls



| tool | route | takes | gives |
|---|---|---|---|
| [si.ask.judge_fit](/reference/tools/si-ask-judge_fit) | [POST /v1/ask/judge_fit](/reference/ask/judge_fit) | Judges one entity against a buyer profile, and against a brand whose offerings' fit is in question | The answer gives the fit with each criterion and its highlights, the temperature with its reason, and the verdict. It makes no lead |
| [si.read.candidates](/reference/tools/si-read-candidates) | [POST /v1/read/candidates](/reference/read/candidates) | Reads the candidates of one brand, narrowed by a buyer profile or by a place | Each candidate arrives with the signals gathered about it, the rung it has reached, and what it still lacks to qualify |
| [si.read.leads](/reference/tools/si-read-leads) | [POST /v1/read/leads](/reference/read/leads) | Reads the leads of one brand, narrowed by a place, a condition or a user | The answer gives the leads, or the package that holds them |
| [si.read.speed_to_lead](/reference/tools/si-read-speed_to_lead) | [POST /v1/read/speed_to_lead](/reference/read/speed_to_lead) | Reads the delay from delivery to the first touch for one brand, over a window | The answer gives the measure's readings, with the population each was read over |
| [si.read.withheld](/reference/tools/si-read-withheld) | [POST /v1/read/withheld](/reference/read/withheld) | Reads the withheld count for one brand or one tenant | The answer gives the count by buyer profile and temperature, with the period and the limit it was read against |
| [si.act.assign](/reference/tools/si-act-assign) | [POST /v1/act/assign](/reference/act/assign) | Assigns one lead to one user by hand, or hands it on | The answer gives the assignment, with the person who made it as its reason |
| [si.act.capacity](/reference/tools/si-act-capacity) | [POST /v1/act/capacity](/reference/act/capacity) | Sets how many new leads one user can take in a period | The answer gives the new capacity, with how many the user holds and when it refills |
| [si.act.mark_lead](/reference/tools/si-act-mark_lead) | [POST /v1/act/mark_lead](/reference/act/mark_lead) | Marks a condition on one lead, with a reason where the condition asks for one | The answer gives the lead's new outcome |
| [si.act.notification_channel](/reference/tools/si-act-notification_channel) | [POST /v1/act/notification_channel](/reference/act/notification_channel) | Writes one notification channel, which is where a notice goes | The channel is ready once its test notice is acknowledged. Until then it is not ready, with the reason |
| [si.act.notification_rule](/reference/tools/si-act-notification_rule) | [POST /v1/act/notification_rule](/reference/act/notification_rule) | Writes one notification rule, which says who is told and never what happens | The answer gives the rule, with the next notice it will send |
| [si.act.routing](/reference/tools/si-act-routing) | [POST /v1/act/routing](/reference/act/routing) | Writes, previews or arms a routing rule from a predicate and the people or the team it attaches | A write or an arm gives the rule. A preview gives the leads it would have admitted and who would have had them, read over history |



## The bars this system enforces

Every bar is a row of the parameter register: an administrator changes it, and the platform reads it by name at the place of enforcement the row records.

| parameter | family | dimension | enforced at |
|---|---|---|---|
| the longest wait of each place of a lead | machinery | a time for each place | the place's reader, which notifies a user past it |
| the bar of fit of a kind of buyer, and the level of its interval | receive | a probability; a level | the judgement of a candidate (MODELS/the-fit-of-a-buyer-and-the-package-of-a-lead, sections 5 and 6) |
| the judgement policy of a kind of buyer: the stages that run and the bar between them | machinery | stages; a probability | the judgement, chosen by the measurement harness on its beat (the same model, section 7) |
| the recency window of an intent observation | receive | a time | the temperature of a lead (the same model, section 6) |


---
title: "The harness"
description: "The harness: the 8 calls this system serves, each a route of the API and a tool of the MCP server, at contract 0476e35e6e275db5."
section: systems
address: /systems/09-the-harness
contract: 0476e35e6e275db5
---

# The harness

The harness: the 8 calls this system serves, each a route of the API and a tool of the MCP server, at contract 0476e35e6e275db5.

[figure: The harness: 8 calls of the contract, by family.]

# The harness

The 8 calls below are the whole of this system on the wire: each is one route of the API and one tool of the MCP server, with one typed input, one card as its answer and one refusal shape. Every answer carries its foot: what was read, the population and the control.

## The calls



| tool | route | takes | gives |
|---|---|---|---|
| [si.ask.sql](/reference/tools/si-ask-sql) | [POST /v1/ask/sql](/reference/ask/sql) | a query, in a strategy | rows, with how many and whether a bound was reached |
| [si.view.waiting](/reference/tools/si-view-waiting) | [POST /v1/view/waiting](/reference/view/waiting) | the caller | notifications, oldest first. Or nothing |
| [si.act.beat](/reference/tools/si-act-beat) | [POST /v1/act/beat](/reference/act/beat) | what runs, and when | the beat |
| [si.act.remember](/reference/tools/si-act-remember) | [POST /v1/act/remember](/reference/act/remember) | a memory and its scope | the memory, or a later fact that ends it |
| [si.act.workflow](/reference/tools/si-act-workflow) | [POST /v1/act/workflow](/reference/act/workflow) | its steps and what starts it | the workflow, and for a preview what it would have done over history, acting on nothing |
| [si.work.run_procedure](/reference/tools/si-work-run_procedure) | [POST /v1/work/run_procedure](/reference/work/run_procedure) | the procedure and its inputs | a task |
| [si.work.status](/reference/tools/si-work-status) | [POST /v1/work/status](/reference/work/status) | the task | its progress. Or nothing |
| [si.harness.delegate](/reference/tools/si-harness-delegate) | [POST /v1/harness/delegate](/reference/harness/delegate) | words, in a strategy | response cards, as they come, and a task where the work goes on |



## The bars this system enforces

Every bar is a row of the parameter register: an administrator changes it, and the platform reads it by name at the place of enforcement the row records.

| parameter | family | dimension | enforced at |
|---|---|---|---|
| a run's deadline and budget | machinery | a time; units | the run |
| a turn's bound of steps | machinery | steps | the turn, which ends with the reason once the model has proposed that many steps |
| the longest wait of a step that waits | machinery | a time | the waiting step, which states what happens when it passes |
| the drain's bound | machinery | a time | the app server's admission, which reports the work still in flight past it |
| the workbench's time budget | machinery | a time | the workbench, which stops a procedure's code past it |
| the app server's loopback address | machinery | a host and a port on the loopback; 127.0.0.1:8891 unless the setting reports otherwise | the local server at start, which binds it for the desktop and the capture extension and rejects any address off the loopback |


---
title: "The API gateway"
description: "The API gateway: the 2 calls this system serves, each a route of the API and a tool of the MCP server, at contract 0476e35e6e275db5."
section: systems
address: /systems/10-the-api-gateway
contract: 0476e35e6e275db5
---

# The API gateway

The API gateway: the 2 calls this system serves, each a route of the API and a tool of the MCP server, at contract 0476e35e6e275db5.

[figure: The API gateway: 2 calls of the contract, by family.]

# The API gateway

The 2 calls below are the whole of this system on the wire: each is one route of the API and one tool of the MCP server, with one typed input, one card as its answer and one refusal shape. Every answer carries its foot: what was read, the population and the control.

## The calls



| tool | route | takes | gives |
|---|---|---|---|
| [si.read.failed_calls](/reference/tools/si-read-failed_calls) | [POST /v1/read/failed_calls](/reference/read/failed_calls) | a tenant | every signed call that did not land, with why, and a way to send it again |
| [si.act.webhook](/reference/tools/si-act-webhook) | [POST /v1/act/webhook](/reference/act/webhook) | the address, what to be told about, and a secret to sign with | the row |



## The bars this system enforces

Every bar is a row of the parameter register: an administrator changes it, and the platform reads it by name at the place of enforcement the row records.

| parameter | family | dimension | enforced at |
|---|---|---|---|
| the service level of a read, for each verb | machinery | a time for each verb | the API gateway, measured at the first build stage and then fixed |
| the bound on tries of a signed call | machinery | a count | the durable work that makes the call |
| how long signed calls that failed are kept | machinery | a time | the store of failed calls |
| the MCP adapter's longest wait for the app server | machinery | a time | the adapter's socket, which opens again on its own after the app server restarts and tries for this long before it refuses a call (stipulated at ninety seconds until the setting row is written) |


---
title: "The ops console"
description: "The ops console: the 9 calls this system serves, each a route of the API and a tool of the MCP server, at contract 0476e35e6e275db5."
section: systems
address: /systems/11-the-ops-console
contract: 0476e35e6e275db5
---

# The ops console

The ops console: the 9 calls this system serves, each a route of the API and a tool of the MCP server, at contract 0476e35e6e275db5.

[figure: The ops console: 9 calls of the contract, by family.]

# The ops console

The 9 calls below are the whole of this system on the wire: each is one route of the API and one tool of the MCP server, with one typed input, one card as its answer and one refusal shape. Every answer carries its foot: what was read, the population and the control.

## The calls



| tool | route | takes | gives |
|---|---|---|---|
| [si.ask.keep_question](/reference/tools/si-ask-keep_question) | [POST /v1/ask/keep_question](/reference/ask/keep_question) | the question and its scope | a saved question |
| [si.read.board](/reference/tools/si-read-board) | [POST /v1/read/board](/reference/read/board) | the board and a period | the board with every tile's numbers, each with its basis and its population |
| [si.view.capabilities](/reference/tools/si-view-capabilities) | [POST /v1/view/capabilities](/reference/view/capabilities) | nothing | the page |
| [si.view.journey](/reference/tools/si-view-journey) | [POST /v1/view/journey](/reference/view/journey) | a unit's id | its hops, back and forward |
| [si.view.oldest](/reference/tools/si-view-oldest) | [POST /v1/view/oldest](/reference/view/oldest) | a kind, a place, and how many | those units, each with its reason and since when |
| [si.view.pairings](/reference/tools/si-view-pairings) | [POST /v1/view/pairings](/reference/view/pairings) | a scope | each pairing, with the units that lack their pair |
| [si.view.stocks](/reference/tools/si-view-stocks) | [POST /v1/view/stocks](/reference/view/stocks) | a part, a kind or a place, and a scope the caller holds | the six numbers for each |
| [si.act.board](/reference/tools/si-act-board) | [POST /v1/act/board](/reference/act/board) | the board with its tiles | the board, ready, or not ready with the tile that could not be drawn |
| [si.work.mine](/reference/tools/si-work-mine) | [POST /v1/work/mine](/reference/work/mine) | the caller | every run the caller started that is still running, each with what it has done, whether it may be stopped, and the tool that stops it |



## The bars this system enforces

Every bar is a row of the parameter register: an administrator changes it, and the platform reads it by name at the place of enforcement the row records.

| parameter | family | dimension | enforced at |
|---|---|---|---|
| the bound on the depth of a journey | machinery | a count of hops | the journey read, which reports when it stops at the bound |


---
title: "The market as it is held"
description: "The market as it is held: the 18 calls this system serves, each a route of the API and a tool of the MCP server, at contract 0476e35e6e275db5."
section: systems
address: /systems/12-the-market-as-it-is-held
contract: 0476e35e6e275db5
---

# The market as it is held

The market as it is held: the 18 calls this system serves, each a route of the API and a tool of the MCP server, at contract 0476e35e6e275db5.

[figure: The market as it is held: 18 calls of the contract, by family.]

# The market as it is held

The 18 calls below are the whole of this system on the wire: each is one route of the API and one tool of the MCP server, with one typed input, one card as its answer and one refusal shape. Every answer carries its foot: what was read, the population and the control.

## The calls



| tool | route | takes | gives |
|---|---|---|---|
| [si.read.audience_map](/reference/tools/si-read-audience_map) | [POST /v1/read/audience_map](/reference/read/audience_map) | a brand, two facets or a facet and a community, the window | the shared subjects, the share, the lift, the negative control that bounds it, and the size as bounds |
| [si.read.brand_design_system](/reference/tools/si-read-brand_design_system) | [POST /v1/read/brand_design_system](/reference/read/brand_design_system) | the brand, and a version, else the newest | the design system as it stands, with every basis |
| [si.read.brand_design_system_changes](/reference/tools/si-read-brand_design_system_changes) | [POST /v1/read/brand_design_system_changes](/reference/read/brand_design_system_changes) | the brand and two versions, else the two newest | every value that differs, by path, with the basis on each side, and the counts |
| [si.read.chain](/reference/tools/si-read-chain) | [POST /v1/read/chain](/reference/read/chain) | a brand | its roles, its handovers and each handover's count with its instrument |
| [si.read.compare](/reference/tools/si-read-compare) | [POST /v1/read/compare](/reference/read/compare) | two brands, a question from the closed list of comparisons | two summaries over one structure, each with its coverage |
| [si.read.map](/reference/tools/si-read-map) | [POST /v1/read/map](/reference/read/map) | a brand, and the two dates | the map |
| [si.read.market](/reference/tools/si-read-market) | [POST /v1/read/market](/reference/read/market) | a brand, a segment, the window | the four stages, each with its count, value, basis and coverage, and the silent remainder |
| [si.read.posture](/reference/tools/si-read-posture) | [POST /v1/read/posture](/reference/read/posture) | a community, the window | open, conditional, closed or unknown, with the two removal rates and the archetype |
| [si.read.roles](/reference/tools/si-read-roles) | [POST /v1/read/roles](/reference/read/roles) | nothing, or one role | the register of roles: each role's side, what it does, what it hands on, which connection holds it, and whether its holder can be a lead |
| [si.read.vertical](/reference/tools/si-read-vertical) | [POST /v1/read/vertical](/reference/read/vertical) | the vertical, or a brand whose vertical is meant | its chain by side with every stock's count and basis, its roles, its segments, its templates, its words and its rules |
| [si.act.bind_buyer](/reference/tools/si-act-bind_buyer) | [POST /v1/act/bind_buyer](/reference/act/bind_buyer) | the kind, an offering or a segment, the weight, the mode | the binding, and the preview of the kind's members |
| [si.act.decide_brand_design](/reference/tools/si-act-decide_brand_design) | [POST /v1/act/decide_brand_design](/reference/act/decide_brand_design) | the brand, the value's path, the decision (accepted, declined, changed) and, when changed, the tenant's own value, with the reason | the decision as a fact at brand scope: the brand's memory, read by the merge, so a changed value stands as stated by the tenant until the site changes and a declined one is never proposed again |
| [si.act.install_pack](/reference/tools/si-act-install_pack) | [POST /v1/act/install_pack](/reference/act/install_pack) | a brand, the pack and its version | the copies made, each naming its origin |
| [si.act.keep_buyer](/reference/tools/si-act-keep_buyer) | [POST /v1/act/keep_buyer](/reference/act/keep_buyer) | the whole profile as it should stand next, with its predicate's tree given in full, its bindings and its ladder | the profile as its next version, ready, or not ready with the compiler's reason; the predicate kept by its hash |
| [si.act.make_brand_design_system](/reference/tools/si-act-make_brand_design_system) | [POST /v1/act/make_brand_design_system](/reference/act/make_brand_design_system) | the brand, and the site when it is not the brand row's own | the brand's design system as the next version of its name: every colour, face, size, step, radius, shadow and the logo, each measured, inferred by a named rule or never measured, with the artefacts it was read from and the gaps; and the same values in the platform's token shape |
| [si.act.map_brand](/reference/tools/si-act-map_brand) | [POST /v1/act/map_brand](/reference/act/map_brand) | a web address, and the brand scope to hold the map | the map as it stands, with every part measured or never measured, and the demand raised |
| [si.act.mark_rival](/reference/tools/si-act-mark_rival) | [POST /v1/act/mark_rival](/reference/act/mark_rival) | a brand, the rival's entity, the evidence | the fact |
| [si.act.seed_tenant](/reference/tools/si-act-seed_tenant) | [POST /v1/act/seed_tenant](/reference/act/seed_tenant) | the manifest and the window | the seed as work, then its receipt with counts by kind and what is not ready |



## The bars this system enforces

Every bar is a row of the parameter register: an administrator changes it, and the platform reads it by name at the place of enforcement the row records.

| parameter | family | dimension | enforced at |
|---|---|---|---|
| the floor of a stage's coverage below which it reads as a lower bound | intend | a share | the read of the stage |
| the deal-size scenario of a market | intend | money | the read of the total stage, its basis a scenario |
| the cap on rivals proposed from evidence for one brand | machinery | a count of entities | the step of the map that finds rivals |
| the longest wait of a market never read before its gap is shown to a user | machinery | a time | the reader of the gap |
| the beat on which a vertical's chain is read | machinery | a time | the platform monitor that keeps the record full in the vertical |
| the cut under which a chain stock's count is shown as a bound and not a number | intend | a count | the reader of the chain |
| the resolution of the hierarchy of cells for places | machinery | a level | the gazetteer's writer, and the sort of every place-keyed table |


---
title: "Strategy, action and learning"
description: "Strategy, action and learning: the 18 calls this system serves, each a route of the API and a tool of the MCP server, at contract 0476e35e6e275db5."
section: systems
address: /systems/13-strategy-action-and-learning
contract: 0476e35e6e275db5
---

# Strategy, action and learning

Strategy, action and learning: the 18 calls this system serves, each a route of the API and a tool of the MCP server, at contract 0476e35e6e275db5.

[figure: Strategy, action and learning: 18 calls of the contract, by family.]

# Strategy, action and learning

The 18 calls below are the whole of this system on the wire: each is one route of the API and one tool of the MCP server, with one typed input, one card as its answer and one refusal shape. Every answer carries its foot: what was read, the population and the control.

## The calls



| tool | route | takes | gives |
|---|---|---|---|
| [si.read.effect](/reference/tools/si-read-effect) | [POST /v1/read/effect](/reference/read/effect) | a move, the window | the effect with its interval, or withheld with what would settle it |
| [si.read.forecasts](/reference/tools/si-read-forecasts) | [POST /v1/read/forecasts](/reference/read/forecasts) | a play or a tactic, across brands | every forecast with its effect, how well the band held, and the proper score by play, tactic, kind of buyer, framing, actor and content |
| [si.read.ledger](/reference/tools/si-read-ledger) | [POST /v1/read/ledger](/reference/read/ledger) | a strategy, the window | every move, action, forecast, effect and impact in order, with the budget spent by kind |
| [si.read.plan_report](/reference/tools/si-read-plan_report) | [POST /v1/read/plan_report](/reference/read/plan_report) | a strategy and a window (`PlanReportInput`) | each play completed, partial or missing, and the items done off plan |
| [si.read.policy_replay](/reference/tools/si-read-policy_replay) | [POST /v1/read/policy_replay](/reference/read/policy_replay) | a policy row and its version, a strategy and a window (`PolicyReplayInput`) | what the policy would have chosen at every logged decision against what was chosen, and the effects that followed (`PolicyReplay`) |
| [si.read.propensity](/reference/tools/si-read-propensity) | [POST /v1/read/propensity](/reference/read/propensity) | a lead, a move or a play, and which faces, actors or content or both (`PropensityInput`) | every eligible actor and every fitting content with the chance, its interval, its basis and the policy's odds, and the one the policy would choose (`PropensityAnswer`) |
| [si.read.strategy](/reference/tools/si-read-strategy) | [POST /v1/read/strategy](/reference/read/strategy) | a strategy, as of a date (`StrategyReadInput`) | the `Strategy` with its life, its game, its graph of plays with each play's class and its reading, the experiments' shares and the frame of its last simulation |
| [si.read.trajectory](/reference/tools/si-read-trajectory) | [POST /v1/read/trajectory](/reference/read/trajectory) | a strategy or one move, and a window (`TrajectoryInput`) | plan item to grounded move to outcome: each move with the items that carried it out, their readings and its effect |
| [si.act.arm_play](/reference/tools/si-act-arm_play) | [POST /v1/act/arm_play](/reference/act/arm_play) | a strategy, the play and its version, the goal it serves, and the share it is armed on with its holdout (a share under one makes the play an experiment) | the armed play with its class proposed from the kind's usual class and the rivals' coverage, and the demand cells it raised |
| [si.act.decide_move](/reference/tools/si-act-decide_move) | [POST /v1/act/decide_move](/reference/act/decide_move) | the move, the caller | the move in its new place, with who moved it |
| [si.act.dry_run](/reference/tools/si-act-dry_run) | [POST /v1/act/dry_run](/reference/act/dry_run) | an action | what it would do, and what the inverse would be |
| [si.act.goal](/reference/tools/si-act-goal) | [POST /v1/act/goal](/reference/act/goal) | a strategy, a measure, a target, a window | the goal, naming the measure's version |
| [si.act.keep_play](/reference/tools/si-act-keep_play) | [POST /v1/act/keep_play](/reference/act/keep_play) | a play for a brand, written once by the platform as an original or by the tenant: its goal, its condition as a predicate over its population, its class, its tactic, the move it proposes, its measure, its window, its forecast rule, its comparison, when it stops, and its graph of moves as edges (`KeepPlayInput`); the predicates given in full are kept by their hashes in the same call | the play as the next version of its name under the brand, ready, or not ready with the first reason: *the condition does not compile*, *the graph has a cycle* naming the edge, *an edge cannot be evaluated* naming the edge and the population, *an edge is neither always nor guarded* |
| [si.act.move_strategy](/reference/tools/si-act-move_strategy) | [POST /v1/act/move_strategy](/reference/act/move_strategy) | a strategy, the place to move it to and the reason (`StrategyMoveInput`): drafted, simulated, rolled out in part, running, paused, ended | the `Strategy` in its new place, with who moved it |
| [si.act.propose_move](/reference/tools/si-act-propose_move) | [POST /v1/act/propose_move](/reference/act/propose_move) | a match of a play | the move, proposed, with its forecast and its assignments as facts |
| [si.act.run_action](/reference/tools/si-act-run_action) | [POST /v1/act/run_action](/reference/act/run_action) | an action prepared by a move | the action, allowed or not allowed with the reason, then running, then done or failed |
| [si.act.strategy](/reference/tools/si-act-strategy) | [POST /v1/act/strategy](/reference/act/strategy) | a brand or brands, a name, a window if any | the strategy, with the standing measures |
| [si.act.undo](/reference/tools/si-act-undo) | [POST /v1/act/undo](/reference/act/undo) | a done action | the action, undone, and the inverse's own action |



## The bars this system enforces

Every bar is a row of the parameter register: an administrator changes it, and the platform reads it by name at the place of enforcement the row records.

| parameter | family | dimension | enforced at |
|---|---|---|---|
| the budget of a strategy, by kind | receive | money, a count of calls, a time, hours | act, where an action leaves *allowed* |
| the longest wait of a proposed move before a user is notified | machinery | a time | the reader of *waiting for a user* |
| the rate of a kind of action under a grant | receive | a count in a time | act |
| the share of the effect's interval above zero below which no cause is claimed | intend | a share | the read of the effect |
| the window of an effect, by kind of move | intend | a time | open a window, measure (stipulated at thirty days until the row is written) |
| how little history gives a range | machinery | a count of readings | the read of the effect, which answers cannot tell under it (stipulated at four readings) |
| how far the comparison may move before the answer is cannot tell | machinery | a share of the measure's own change | the read of the effect (stipulated at one: the comparison moving as much as the measure) |
| the smallest effect the data can resolve | machinery | a share of the measure | the read of the effect, carried on every effect answer as its floor (stipulated at a twentieth until read by redrawing) |
| the samples and the level of a composition across a graph | machinery | a count, and a share | the composition by sampling of a play's graph (stipulated at 512 samples at the 80 percent level) |
| the share by which arithmetic on the ends may exceed a sampled interval | machinery | a share of the sampled width | the check that an interval composes by sampling (stipulated at a tenth) |
| the line on a play's own measure at which it stops | intend | the measure's dimension | the play's reader, on its beat |
| the time a lead may go without a touch before it is gone quiet | intend | a time | the reader of the lead |
| the sensitivity bound under which a play reads beta | intend | a share of the trajectory's change (stipulated at a tenth) | the class reading, on its beat |
| the scoring rule by kind of forecast | machinery | a row (stipulated as CRPS for a band and Brier for a chance) | the score of a forecast against its effect, on the beat |
| the propensity floor under which an actor or content is not routed | intend | a chance (stipulated at a twentieth) | the routing answer |
| the holdout share of an experiment where the arming names none | intend | a share (stipulated at a fifth) | arm a play |
| the tolerance between the share asked and the share read | intend | a share (stipulated at a fiftieth) | the control of the strategy's read, and the experiment check |
| the policy a strategy chooses its ready arms by where it names none | intend | a row of the policies register (stipulated as Thompson sampling, version 1) | the choice among ready arms |
| the interference rule when two plays would read one measure over one group | machinery | a row: refuse, disjoint groups, or accept cannot tell (stipulated as refuse; decision ) | arm a play, at the scheduler |
| the confidence of a control that reads a share from a split | machinery | a share (stipulated at 99 percent: a control that fails one fair split in five at the reporting level is no control) | the strategy read's control, and every control that compares a share read from assignments with the share asked |


---
title: "Models and intelligence"
description: "Models and intelligence: the 4 calls this system serves, each a route of the API and a tool of the MCP server, at contract 0476e35e6e275db5."
section: systems
address: /systems/14-models-and-intelligence
contract: 0476e35e6e275db5
---

# Models and intelligence

Models and intelligence: the 4 calls this system serves, each a route of the API and a tool of the MCP server, at contract 0476e35e6e275db5.

[figure: Models and intelligence: 4 calls of the contract, by family.]

# Models and intelligence

The 4 calls below are the whole of this system on the wire: each is one route of the API and one tool of the MCP server, with one typed input, one card as its answer and one refusal shape. Every answer carries its foot: what was read, the population and the control.

## The calls



| tool | route | takes | gives |
|---|---|---|---|
| [si.read.estimate](/reference/tools/si-read-estimate) | [POST /v1/read/estimate](/reference/read/estimate) | an estimator, the case | the estimate with its interval, its evidence and its familiarity, or withheld |
| [si.read.instruction_set](/reference/tools/si-read-instruction_set) | [POST /v1/read/instruction_set](/reference/read/instruction_set) | nothing | the set at its current version, assembled |
| [si.read.intelligence](/reference/tools/si-read-intelligence) | [POST /v1/read/intelligence](/reference/read/intelligence) | a subject and a kind of intelligence | the kind's facts about the subject with their basis, their coverage and their date |
| [si.read.methods](/reference/tools/si-read-methods) | [POST /v1/read/methods](/reference/read/methods) | a question, or nothing | the methods that answer it, or every method, each with its readiness |



## The bars this system enforces

Every bar is a row of the parameter register: an administrator changes it, and the platform reads it by name at the place of enforcement the row records.

| parameter | family | dimension | enforced at |
|---|---|---|---|
| the floor of calibration, by segment | intend | a share | the read of the statistics, on the beat |
| the length of the shadow period | machinery | a time, or a count of decisions | the move from in shadow to frozen |
| the budget of model calls a lead, and a strategy | receive | a count, and money | the models role, at the call |
| the sample of the audit of a layer, and its beat | machinery | a count, and a time | the audit |
| the address of each served model | machinery | an address, with no default | the models role, at start |


---
title: "Documents from the record"
description: "Documents from the record: the 5 calls this system serves, each a route of the API and a tool of the MCP server, at contract 0476e35e6e275db5."
section: systems
address: /systems/17-documents-from-the-record
contract: 0476e35e6e275db5
---

# Documents from the record

Documents from the record: the 5 calls this system serves, each a route of the API and a tool of the MCP server, at contract 0476e35e6e275db5.

[figure: Documents from the record: 5 calls of the contract, by family.]

# Documents from the record

The 5 calls below are the whole of this system on the wire: each is one route of the API and one tool of the MCP server, with one typed input, one card as its answer and one refusal shape. Every answer carries its foot: what was read, the population and the control.

## The calls



| tool | route | takes | gives |
|---|---|---|---|
| [si.read.document](/reference/tools/si-read-document) | [POST /v1/read/document](/reference/read/document) | the document, the version, the caller | the version, with when it was built and what it was built from |
| [si.read.document_changes](/reference/tools/si-read-document_changes) | [POST /v1/read/document_changes](/reference/read/document_changes) | two versions | every number that moved with its unit, every figure replaced |
| [si.act.build_document](/reference/tools/si-act-build_document) | [POST /v1/act/build_document](/reference/act/build_document) | the document, the two dates, which default to now | the build, then the version, or not ready with every number that is missing |
| [si.act.publish](/reference/tools/si-act-publish) | [POST /v1/act/publish](/reference/act/publish) | the version, the address, the visibility | the publishing, proposed or published, and its receipt |
| [si.act.withdraw](/reference/tools/si-act-withdraw) | [POST /v1/act/withdraw](/reference/act/withdraw) | a publishing | the publishing, withdrawn |



## The bars this system enforces

Every bar is a row of the parameter register: an administrator changes it, and the platform reads it by name at the place of enforcement the row records.

| parameter | family | dimension | enforced at |
|---|---|---|---|
| the beat on which published documents are rebuilt | machinery | a time | the reader of published documents |
| the longest a build may run | machinery | a time | the build |
| the largest document a key may fetch without a sign-in | receive | bytes | the read |


---
title: "The acquisition system and the connector standard"
description: "The acquisition system and the connector standard: the 28 calls this system serves, each a route of the API and a tool of the MCP server, at contract 0476e35e6e275db5."
section: systems
address: /systems/18-the-acquisition-system-and-the-connector-standard
contract: 0476e35e6e275db5
---

# The acquisition system and the connector standard

The acquisition system and the connector standard: the 28 calls this system serves, each a route of the API and a tool of the MCP server, at contract 0476e35e6e275db5.

[figure: The acquisition system and the connector standard: 28 calls of the contract, by family.]

# The acquisition system and the connector standard

The 28 calls below are the whole of this system on the wire: each is one route of the API and one tool of the MCP server, with one typed input, one card as its answer and one refusal shape. Every answer carries its foot: what was read, the population and the control.

## The calls



| tool | route | takes | gives |
|---|---|---|---|
| [si.ask.get_content](/reference/tools/si-ask-get_content) | [POST /v1/ask/get_content](/reference/ask/get_content) | a `ContentRequest` | a `ContentResponse`, the page in bronze |
| [si.ask.propose_template](/reference/tools/si-ask-propose_template) | [POST /v1/ask/propose_template](/reference/ask/propose_template) | a `ProposeTemplateInput` | a draft template with fields and evidence spans for the person to confirm |
| [si.ask.read_source](/reference/tools/si-ask-read_source) | [POST /v1/ask/read_source](/reference/ask/read_source) | the installed connector, the kind, a cursor | a page of source objects, the next cursor, the cells credited |
| [si.ask.scrape](/reference/tools/si-ask-scrape) | [POST /v1/ask/scrape](/reference/ask/scrape) | a `ScrapeRequest` | a `ScrapeResult`, the rows as source objects with their evidence spans |
| [si.ask.search](/reference/tools/si-ask-search) | [POST /v1/ask/search](/reference/ask/search) | a `SearchRequest` | `SearchResult` rows, streamed as engines answer, credited to cells |
| [si.read.browse_view](/reference/tools/si-read-browse_view) | [POST /v1/read/browse_view](/reference/read/browse_view) | a `BrowseViewInput` | one frame of the page as the person sees it, with its size and address, for a dashboard that shows the session live and forwards the person's clicks and words as steps |
| [si.read.catalogue](/reference/tools/si-read-catalogue) | [POST /v1/read/catalogue](/reference/read/catalogue) | a tenant or a brand | every source and connector with its kinds of reading and action, its state, the identity it needs, its cost, its rights, its coverage and its health |
| [si.read.coverage_by_cell](/reference/tools/si-read-coverage_by_cell) | [POST /v1/read/coverage_by_cell](/reference/read/coverage_by_cell) | a source, or a scope with a window | measured, never measured with the reason, withheld |
| [si.read.lineage](/reference/tools/si-read-lineage) | [POST /v1/read/lineage](/reference/read/lineage) | an artefact | its whole history and footprint, marking unavailable what a store cannot answer |
| [si.read.page_changes](/reference/tools/si-read-page_changes) | [POST /v1/read/page_changes](/reference/read/page_changes) | a `PageChangesInput` | `PageChange` rows for the site or the watch in the window |
| [si.read.scrape_runs](/reference/tools/si-read-scrape_runs) | [POST /v1/read/scrape_runs](/reference/read/scrape_runs) | a `ScrapeRunsInput` | `ScrapeRun` rows with pages, rows, bytes, cost and time |
| [si.read.source_procedure](/reference/tools/si-read-source_procedure) | [POST /v1/read/source_procedure](/reference/read/source_procedure) | a source | its procedure at its version, the date of its last reading and whether it is stale |
| [si.act.act_through_connector](/reference/tools/si-act-act_through_connector) | [POST /v1/act/act_through_connector](/reference/act/act_through_connector) | the installed connector, the kind, the arguments with their sources | a move, proposed or running by the grant's mode; then the source's own id for what was done |
| [si.act.browse_step](/reference/tools/si-act-browse_step) | [POST /v1/act/browse_step](/reference/act/browse_step) | a `BrowseStepInput` | the step's result: the accessibility tree, the text, the markdown, a screenshot's hash, or a download set |
| [si.act.capture](/reference/tools/si-act-capture) | [POST /v1/act/capture](/reference/act/capture) | the document, the network events, the address, the person's identity | the capture with its source objects and the cells credited |
| [si.act.crawl](/reference/tools/si-act-crawl) | [POST /v1/act/crawl](/reference/act/crawl) | a `ScrapeRequest` whose scope names the site's seeds, with sitemap-driven discovery on | the `ScrapeRun`, queued, or the run that already stands for the same template version and scope inside its freshness; every page lands as a capture through the one pipeline, and each page that could not be read is a gap with its reason |
| [si.act.hold_identity](/reference/tools/si-act-hold_identity) | [POST /v1/act/hold_identity](/reference/act/hold_identity) | the platform, the scopes the rows declare | a browser session for the person; then the credential with its vault entry |
| [si.act.probe_identity](/reference/tools/si-act-probe_identity) | [POST /v1/act/probe_identity](/reference/act/probe_identity) | the identity | its readiness with the reason |
| [si.act.scrape_template](/reference/tools/si-act-scrape_template) | [POST /v1/act/scrape_template](/reference/act/scrape_template) | a `TemplateInput` | the template, ready or not ready with the reason; for a preview, the rows from its samples and a bounded live scope |
| [si.act.set_aside_run](/reference/tools/si-act-set_aside_run) | [POST /v1/act/set_aside_run](/reference/act/set_aside_run) | a `SetAsideRunInput`: the run's key and a person's plain reason | the `ScrapeRun`, kept in the parked place with the reason, which the beat never takes up; each move is an event with the reason |
| [si.act.sync_rule](/reference/tools/si-act-sync_rule) | [POST /v1/act/sync_rule](/reference/act/sync_rule) | the installed connector, the offer, the fields of section 2.8 | the rule; for a preview, what it would read and push |
| [si.act.undo_action](/reference/tools/si-act-undo_action) | [POST /v1/act/undo_action](/reference/act/undo_action) | the move | the inverse move |
| [si.act.watch_site](/reference/tools/si-act-watch_site) | [POST /v1/act/watch_site](/reference/act/watch_site) | a `WatchSiteInput` | the watch, ready or not ready; for a preview, the pages it would read and the changes it would have raised over the window |
| [si.work.backfill](/reference/tools/si-work-backfill) | [POST /v1/work/backfill](/reference/work/backfill) | a source, an access method, a window, a plane | the job; then partitions carrying the window |
| [si.work.browse_open](/reference/tools/si-work-browse_open) | [POST /v1/work/browse_open](/reference/work/browse_open) | a `BrowseOpenInput` | the session, opened, with its live view |
| [si.work.browse_take_over](/reference/tools/si-work-browse_take_over) | [POST /v1/work/browse_take_over](/reference/work/browse_take_over) | a `BrowseTakeOverInput` | the session, driven by the person or handed back |
| [si.work.download_set](/reference/tools/si-work-download_set) | [POST /v1/work/download_set](/reference/work/download_set) | a `DownloadInput` | `DownloadJob` rows, one per file |
| [si.work.download_set_control](/reference/tools/si-work-download_set_control) | [POST /v1/work/download_set_control](/reference/work/download_set_control) | a `DownloadControlInput` | the jobs in their new place |



## The bars this system enforces

Every bar is a row of the parameter register: an administrator changes it, and the platform reads it by name at the place of enforcement the row records.

| parameter | family | dimension | enforced at |
|---|---|---|---|
| the system's declared capacity | machinery | jobs | dequeue |
| a run's storage residency limit | machinery | bytes | every bulk-path write |
| attempt caps, by failure class | machinery | count | the reconciler |
| an access method's politeness budget and rate limit | source | calls per unit of time | the call, under the lease |
| a browser's page count and age before recycling | machinery | count; a time | the pool, at release |
| a browser pool's leases open at once and the wait for one | machinery | count; a time | the pool, at each lease |
| the wait of a person's capture for the record's writer | machinery | a time (stipulated at ten seconds, under the extension's wait of fifteen) | the capture tool, at the deposit: past the wait the capture is refused by name and sent again |
| a network proxy pool's spend ceiling | receive | money per period | the exit, at the call |
| a browsing session's longest life and its step rate | machinery | a time; steps per unit of time; milliseconds a step settles before its reading | the pool, at each step (the settle is 300 ms, stipulated, and a step that asks for no reading does not settle) |
| a download set's residency and its per-file size cap | machinery | bytes | the download manager, at every block |
| the crawls a beat takes | machinery | runs per tick; runs open at once | the crawl beat, at each tick |
| the probe of a held identity | machinery | a time between two probes of one identity | the beat that probes the held identities, at each tick (six hours, stipulated) |
| an address found under a person's held account | source | waits or runs | the crawl, as a walk queues what it found under a person's own account: *waits* keeps it in the parked place with its reason |


---
title: "Operations, security and observability"
description: "Operations, security and observability: the 4 calls this system serves, each a route of the API and a tool of the MCP server, at contract 0476e35e6e275db5."
section: systems
address: /systems/19-operations-security-and-observability
contract: 0476e35e6e275db5
---

# Operations, security and observability

Operations, security and observability: the 4 calls this system serves, each a route of the API and a tool of the MCP server, at contract 0476e35e6e275db5.

[figure: Operations, security and observability: 4 calls of the contract, by family.]

# Operations, security and observability

The 4 calls below are the whole of this system on the wire: each is one route of the API and one tool of the MCP server, with one typed input, one card as its answer and one refusal shape. Every answer carries its foot: what was read, the population and the control.

## The calls



| tool | route | takes | gives |
|---|---|---|---|
| [si.read.invoices](/reference/tools/si-read-invoices) | [POST /v1/read/invoices](/reference/read/invoices) | a period, or nothing | the invoices with their states |
| [si.read.usage_statement](/reference/tools/si-read-usage_statement) | [POST /v1/read/usage_statement](/reference/read/usage_statement) | a period | the tenant's usage of the period by kind, priced, against the plan |
| [si.view.usage](/reference/tools/si-view-usage) | [POST /v1/view/usage](/reference/view/usage) | a tenant, a kind, a provider, a window | quantity and cost by kind, by tenant, by provider and by period, with each provider's reconciliation state |
| [si.act.change_plan](/reference/tools/si-act-change_plan) | [POST /v1/act/change_plan](/reference/act/change_plan) | the plan kind | the change as a proposal, and the provider's own page for payment |



## The bars this system enforces

Every bar is a row of the parameter register: an administrator changes it, and the platform reads it by name at the place of enforcement the row records.

| parameter | family | dimension | enforced at |
|---|---|---|---|
| the longest a service may take to publish ready after starting | machinery | a time | the alarm on a service's life |
| the age at which a backup reads not current | machinery | a time, two days by default | the reader of backups |
| the beat of the restore drill, and of the proof of the trails' chains | machinery | a time | the beats |
| the ceiling on cost by kind, and the share that raises an alarm | receive | money, and a share | the reader of cost |
| how long traces and logs are kept | machinery | a time | the telemetry collector |


---
title: "The capture extension: a person's own browser as a capture surface"
description: "The capture extension: a person's own browser as a capture surface: the 7 calls this system serves, each a route of the API and a tool of the MCP server, at contract 0476e35e6e275db5."
section: systems
address: /systems/24-the-capture-extension-a-person-s-own-browser-as-a-capture-surface
contract: 0476e35e6e275db5
---

# The capture extension: a person's own browser as a capture surface

The capture extension: a person's own browser as a capture surface: the 7 calls this system serves, each a route of the API and a tool of the MCP server, at contract 0476e35e6e275db5.

[figure: The capture extension: a person's own browser as a capture surface: 7 calls of the contract, by family.]

# The capture extension: a person's own browser as a capture surface

The 7 calls below are the whole of this system on the wire: each is one route of the API and one tool of the MCP server, with one typed input, one card as its answer and one refusal shape. Every answer carries its foot: what was read, the population and the control.

## The calls



| tool | route | takes | gives |
|---|---|---|---|
| [si.read.capture_health](/reference/tools/si-read-capture_health) | [POST /v1/read/capture_health](/reference/read/capture_health) | a platform and a window, or nothing | captures by platform in the window against the window before, with a verdict |
| [si.read.capture_rules](/reference/tools/si-read-capture_rules) | [POST /v1/read/capture_rules](/reference/read/capture_rules) | a platform, or nothing | the rules with each platform's readiness |
| [si.read.grounding_priors](/reference/tools/si-read-grounding_priors) | [POST /v1/read/grounding_priors](/reference/read/grounding_priors) | a platform, or nothing (`GroundingPriorsInput`) | how often a person supported each kind of suggestion at each breadth, one row per kind, platform and breadth (`GroundingPriors`) |
| [si.read.groundings](/reference/tools/si-read-groundings) | [POST /v1/read/groundings](/reference/read/groundings) | one capture's, one entity's, or every grounding in a place | each grounding with its hypotheses |
| [si.act.annotate](/reference/tools/si-act-annotate) | [POST /v1/act/annotate](/reference/act/annotate) | an `Annotation` with the target *an entity* and the entity's id, from the web shell, the desktop shell, the agent or the API; in the side panel the same type travels inside the page's reading | the fact the person stated, a claim or a connection, by its id and kind (`UnitRef`) |
| [si.act.capture_rule](/reference/tools/si-act-capture_rule) | [POST /v1/act/capture_rule](/reference/act/capture_rule) | the rule | the rule, ready or not ready with the reason |
| [si.act.ground](/reference/tools/si-act-ground) | [POST /v1/act/ground](/reference/act/ground) | exactly one of a capture, an entity, a text or an address, and a breadth (`GroundInput`) | the grounding with its hypotheses (`GroundingAnswer`), the channels that ran and the ones not ready with their reason |



## The bars this system enforces

Every bar is a row of the parameter register: an administrator changes it, and the platform reads it by name at the place of enforcement the row records.

| parameter | family | dimension | enforced at |
|---|---|---|---|
| the queue's cap | machinery | bytes; days | the service worker |
| the depth of a deepening | machinery | hops from the thing deepened | the deepening, when a thing is fetched in full along its relations |
| the largest artefact | machinery | bytes | the content script, before hashing |
| the neighbourhood's bound | machinery | items; people | the content script |
| the delivery retry | machinery | attempts; hours | the service worker |
| the preview's freshness | machinery | seconds | the panel |
| the walk's budget | machinery | rounds; items; seconds; milliseconds between rounds | the in-page reader, on a template whose navigation has a scroll step |
| the automatic capture's times | machinery | seconds | the service worker under *every page I open* |
| the bundle budgets | machinery | kilobytes | the build |
| the breadth of grounding | intend | a choice of exact, similar, related or broad | the grounding |
| the bars of nearness | machinery | a share for the name channel and a share for the meaning channel, per breadth (`BarsOfNearness`) | the grounding, on every channel; the compiler, when a leaf of a predicate names a breadth |
| the embedding model | machinery | a model row of the embedder kind | the semantic search |
| the retention of raw captures | machinery | days | the retirement of bronze artefacts |
| the person's account logins by platform | intend | a map of platform to login | the walk, on the beat that reads the person's own activity through a platform's API |


---
title: "The economics of the market: business models, benchmarks, the return to a buyer, and prices"
description: "The economics of the market: business models, benchmarks, the return to a buyer, and prices: the 6 calls this system serves, each a route of the API and a tool of the MCP server, at contract 0476e35e6e275db5."
section: systems
address: /systems/25-the-economics-of-the-market-business-models-benchmarks-the-return-to-a-buyer-and-prices
contract: 0476e35e6e275db5
---

# The economics of the market: business models, benchmarks, the return to a buyer, and prices

The economics of the market: business models, benchmarks, the return to a buyer, and prices: the 6 calls this system serves, each a route of the API and a tool of the MCP server, at contract 0476e35e6e275db5.

[figure: The economics of the market: business models, benchmarks, the return to a buyer, and prices: 6 calls of the contract, by family.]

# The economics of the market: business models, benchmarks, the return to a buyer, and prices

The 6 calls below are the whole of this system on the wire: each is one route of the API and one tool of the MCP server, with one typed input, one card as its answer and one refusal shape. Every answer carries its foot: what was read, the population and the control.

## The calls



| tool | route | takes | gives |
|---|---|---|---|
| [si.economics.benchmarks](/reference/tools/si-economics-benchmarks) | [POST /v1/economics/benchmarks](/reference/economics/benchmarks) | a driver, and a population or a buyer profile | the benchmarks that apply, each with its interval, population, period, source and what its rights allow |
| [si.economics.estimate](/reference/tools/si-economics-estimate) | [POST /v1/economics/estimate](/reference/economics/estimate) | `EstimateReturnInput`: the buyer (an entity, a lead, a buyer profile or a session), the offering or tier, the stated numbers, and whether to simulate | a `Card` whose body is a `FrameOfASale` |
| [si.economics.ladder](/reference/tools/si-economics-ladder) | [POST /v1/economics/ladder](/reference/economics/ladder) | nothing, or a version | the price ladder in force with its study |
| [si.economics.models](/reference/tools/si-economics-models) | [POST /v1/economics/models](/reference/economics/models) | a vertical, a segment or a buyer profile | the business models that apply, each with its readiness, its drivers and its outputs |
| [si.economics.offer](/reference/tools/si-economics-offer) | [POST /v1/economics/offer](/reference/economics/offer) | `ReadingOfferedInput`: the buyer profile, the model, the drivers to ask | the reading offered, ready or not ready with the reason, and its page's address |
| [si.economics.study](/reference/tools/si-economics-study) | [POST /v1/economics/study](/reference/economics/study) | `PricingStudyInput`: the methods to run, the buyer profiles, the rivals' window | the study as a fact and its candidate ladders as a set of options |



## The bars this system enforces

Every bar is a row of the parameter register: an administrator changes it, and the platform reads it by name at the place of enforcement the row records.

| parameter | family | dimension | enforced at |
|---|---|---|---|
| the most drivers a reading offered may ask a stranger to state | intend | a count | the readiness gate of the reading offered |
| the sample count and the time budget of a simulation | machinery | a count, and a time | the simulation run |
| the level of every interval this part reports | intend | a share | the evaluator, on every estimate |
| the payback bar under which a signal is raised, by buyer profile | intend | a duration | the monitor of the economic signal |
| the position on the rivals' distribution a tier is set at, by tier | intend | a share (a quantile) | the pricing study |
| the floor of gross margin a ladder must clear against the cost of a lead and of a call | intend | a share | the margin check of the pricing study |
| the retention class of a stranger's stated numbers | receive | a retention class row | the write of the buyer's own numbers from a public page |
| the bounds of a stated driver, by driver | source | the driver's dimension | the write of the buyer's own numbers |
| the longest age of a benchmark before a frame reads it as stale | intend | a time | the evaluator, which marks the input |
| the platform's uplift to a buyer's pipeline, as a low, a middle and a high, by buyer profile | intend | a share | the evaluator, as the stipulated position of that driver until the outcome ledger measures the effect; every page discloses it as a range and its basis |


---
title: "The market as a living system: value chains, systems models, templates and the search for product-market fit"
description: "The market as a living system: value chains, systems models, templates and the search for product-market fit: the 13 calls this system serves, each a route of the API and a tool of the MCP server, at contract 0476e35e6e275db5."
section: systems
address: /systems/26-the-market-as-a-living-system-value-chains-systems-models-templates-and-the-search-for-product-market-fit
contract: 0476e35e6e275db5
---

# The market as a living system: value chains, systems models, templates and the search for product-market fit

The market as a living system: value chains, systems models, templates and the search for product-market fit: the 13 calls this system serves, each a route of the API and a tool of the MCP server, at contract 0476e35e6e275db5.

[figure: The market as a living system: value chains, systems models, templates and the search for product-market fit: 13 calls of the contract, by family.]

# The market as a living system: value chains, systems models, templates and the search for product-market fit

The 13 calls below are the whole of this system on the wire: each is one route of the API and one tool of the MCP server, with one typed input, one card as its answer and one refusal shape. Every answer carries its foot: what was read, the population and the control.

## The calls



| tool | route | takes | gives |
|---|---|---|---|
| [si.read.fit_frame](/reference/tools/si-read-fit_frame) | [POST /v1/read/fit_frame](/reference/read/fit_frame) | Reads the frame of one fit search | The answer gives the markets ranked, the offering sculpted for each buyer profile, the tactics proposed to test the fit, the verdict for each market, and the set of options that compares them |
| [si.read.fit_plays](/reference/tools/si-read-fit_plays) | [POST /v1/read/fit_plays](/reference/read/fit_plays) | Reads the tactics that fit one phase of the search, for a vertical or a kind of offering | The answer gives the tactics in the order to run them |
| [si.read.market_twin](/reference/tools/si-read-market_twin) | [POST /v1/read/market_twin](/reference/read/market_twin) | Reads one market twin, and the date to read it as of | The answer gives the twin: the model family and template it was instanced from, the participants placed on the chain, the level of every stock as of the date, the simulations run on it in order, and the strategy whose armed plays are its interventions |
| [si.read.model_families](/reference/tools/si-read-model_families) | [POST /v1/read/model_families](/reference/read/model_families) | Reads the model families that fit a vertical or a representation | Each family arrives with what it represents, the substrate it is written over, its solver and its check |
| [si.read.simulation_frame](/reference/tools/si-read-simulation_frame) | [POST /v1/read/simulation_frame](/reference/read/simulation_frame) | Reads the frame of one simulation | The answer gives the trajectory of every stock, the gain of every loop, the sensitivity to every intervention, and the set of options that compares strategies laid over the same template |
| [si.read.systems_models](/reference/tools/si-read-systems_models) | [POST /v1/read/systems_models](/reference/read/systems_models) | Reads the systems models that fit one vertical or one kind of offering | Each template arrives with its readiness and the defect it carries named |
| [si.read.value_chain](/reference/tools/si-read-value_chain) | [POST /v1/read/value_chain](/reference/read/value_chain) | Reads the value chain of one vertical, with the brand whose participants are placed on it | The answer gives the chain's stocks and handovers with their counts, the participants on each stock, and the loops the templates name over it |
| [si.act.make_market_twin](/reference/tools/si-act-make_market_twin) | [POST /v1/act/make_market_twin](/reference/act/make_market_twin) | Makes one market twin from a vertical, a segment, a brand, a template and the way of going to market it serves | The answer gives the twin, ready or not ready with the stock the record cannot read named |
| [si.act.place_participant](/reference/tools/si-act-place_participant) | [POST /v1/act/place_participant](/reference/act/place_participant) | Places one party in one role on one stock of a vertical's chain, with the evidence for it | The answer gives the participant, ready or not ready with the reason |
| [si.act.record_fit_reading](/reference/tools/si-act-record_fit_reading) | [POST /v1/act/record_fit_reading](/reference/act/record_fit_reading) | Records one result of a person's own test: the tactic, the market, the measure, its value, the sample and where it came from | The answer gives the reading as a fact the record keeps |
| [si.work.lay_strategy](/reference/tools/si-work-lay_strategy) | [POST /v1/work/lay_strategy](/reference/work/lay_strategy) | Lays one strategy on one twin, with the bounds of the run | The call returns the simulation whose interventions are the strategy's armed plays, then the frame |
| [si.work.search_fit](/reference/tools/si-work-search_fit) | [POST /v1/work/search_fit](/reference/work/search_fit) | Searches for product-market fit from one end: an offering looking for its markets, or a concept looking for a market | The call returns the search as work, then the frame that holds what it settled |
| [si.work.simulate_market](/reference/tools/si-work-simulate_market) | [POST /v1/work/simulate_market](/reference/work/simulate_market) | Runs one systems model template over a market, with the interventions to try and the bounds of the run | The call returns the simulation as work, then the frame that holds what it reached |



## The bars this system enforces

Every bar is a row of the parameter register: an administrator changes it, and the platform reads it by name at the place of enforcement the row records.

| parameter | family | dimension | enforced at |
|---|---|---|---|
| the longest horizon of a market simulation, by template | machinery | a time | the readiness gate of the simulation's input |
| the finest step of a market simulation | machinery | a time | the readiness gate of the simulation's input |
| the sample count and the time budget of a market simulation | machinery | a count, and a time | the simulation, which stops with the trajectories it reached |
| the level of every interval a frame of a simulation reports | intend | a share | the stepping, on every trajectory |
| the bar a candidate market's score must clear to be proposed | intend | a share | the search's step of the candidate markets |
| the count of rivals running a play above which it reads table stakes | intend | a count | the tactic *alpha against table stakes*, and the class reading on the beat (stipulated at three until a market's reading sets the row) |
| the share very disappointed that reads fit | intend | a share | the tactic *the very-disappointed survey* |
| the window a fit reading stays good for, by tactic | intend | a time | the search's testing step, which marks a stale reading |
| the most tactics a search proposes per phase | intend | a count | the search's step of the plays to test |
| the retention class of a fit reading a stranger submits | receive | a retention class row | the write of a fit reading from a form |
| the fewest participants for which the stocks-and-flows run stands in for the agents' run | machinery | a count | the readiness gate of the twin's family (MODELS/the-market-as-a-formal-model.md section 4) |
| the fewest units a stock holds before its flows step deterministically | machinery | a count | the stepping, per stock and step |
| the stages of a delay | machinery | a count | the stepping of a delayed flow |
| the fewest sequences a learned latent model needs, and the shortest length of a sequence | machinery | a count, and a count | the readiness gate of the sixth model family |
| the off-path error a learned latent model may not exceed, as a multiple of its on-path error | intend | a number | the readiness gate of the sixth model family, on held-out counterfactual play sequences |
| the strength of pooling toward a parent segment | intend | a count | the estimator of a hazard |
| the tolerance of interval coverage | intend | a share | the coverage check on the beat |
| the draws of a simulation-based calibration | machinery | a count | the check on an estimator before any real count reaches it |
| the fewest ready families an ensemble needs, and the step of the coverage adjustment | intend | a count, and a share | the frame's composition when a family reads not ready for coverage, and the interval's adjustment under drift |
| the exploitability tolerance of a solved game, and the most rounds of its solver | machinery | a share of the payoff's scale, and a count | the solver of the game of roles and of the mean-field game |
| the propensity floor of a randomised play | intend | a share | the planner of the learned latent model |
| the ratio of variance to mean above which an inflow draws as a negative binomial | machinery | a number | the stepping of an absolute inflow |


---
title: "specification app"
description: "specification app: the 8 calls this system serves, each a route of the API and a tool of the MCP server, at contract 0476e35e6e275db5."
section: systems
address: /systems/app-specification-app
contract: 0476e35e6e275db5
---

# specification app

specification app: the 8 calls this system serves, each a route of the API and a tool of the MCP server, at contract 0476e35e6e275db5.

[figure: specification app: 8 calls of the contract, by family.]

# specification app

The 8 calls below are the whole of this system on the wire: each is one route of the API and one tool of the MCP server, with one typed input, one card as its answer and one refusal shape. Every answer carries its foot: what was read, the population and the control.

## The calls



| tool | route | takes | gives |
|---|---|---|---|
| [si.session.sign_in](/reference/tools/si-session-sign_in) | [POST /v1/session/sign_in](/reference/session/sign_in) | nothing, or the tenant to sign in to | the way the browser was opened, then the caller as a view once the code came back; the refresh token goes to the keychain and never to the caller |
| [si.session.cache](/reference/tools/si-session-cache) | [POST /v1/session/cache](/reference/session/cache) | nothing, or a call to forget | what the app holds from earlier answers, by call and date, and when each expires |
| [si.ask.local](/reference/tools/si-ask-local) | [POST /v1/ask/local](/reference/ask/local) | a question in one of the ask tools' owning types, over the files the app may read | the card, answered by the app's own engine over its tenant's files, with the same foot |
| [si.work.local_procedure](/reference/tools/si-work-local_procedure) | [POST /v1/work/local_procedure](/reference/work/local_procedure) | a named procedure whose inputs are files in the workspace | a task run by the app with its steps in the app's own journal, resumable |
| [si.files.download](/reference/tools/si-files-download) | [POST /v1/files/download](/reference/files/download) | a file's pointer from a task or a document, and where in the workspace to put it | progress by bytes moved of bytes in all, then the path inside the workspace |
| [si.files.upload](/reference/tools/si-files-upload) | [POST /v1/files/upload](/reference/files/upload) | a path inside the workspace, and what the file is for | progress, then the pointer the platform kept |
| [si.files.list](/reference/tools/si-files-list) | [POST /v1/files/list](/reference/files/list) | a path inside the workspace, or nothing | the files with their sizes, kinds and when they were written |
| [si.files.workspace](/reference/tools/si-files-workspace) | [POST /v1/files/workspace](/reference/files/workspace) | nothing, or a folder to make the workspace | the workspace folder, and every act the app made in it on the ledger |


---
title: "The API and the MCP server"
description: "Every route and every tool of the platform at contract 0476e35e6e275db5. Every route takes a POST with a typed body and four headers, and returns one card shape or one error shape."
section: reference
address: /reference
contract: 0476e35e6e275db5
---

# The API and the MCP server

Every route and every tool of the platform at contract 0476e35e6e275db5. Every route takes a POST with a typed body and four headers, and returns one card shape or one error shape.

[figure: Every route and every tool belongs to one family.]

Generated from the tool register and the type register; never edited by hand. Every operation is POST with a typed body, four envelope headers, one answer shape and one error shape. Register hash 0476e35e6e275db5.

## Routes


| route | purpose | tool | long step |
|---|---|---|---|
| [`/v1/session/my_grants`](/reference/session/my_grants) | the caller, and a place to its permissions there, after all three narrowings | [`si.session.my_grants`](/reference/tools/si-session-my_grants) |  |
| [`/v1/session/my_scopes`](/reference/session/my_scopes) | the caller to the scopes it reads, set on the database transaction before any query runs | [`si.session.my_scopes`](/reference/tools/si-session-my_scopes) |  |
| [`/v1/session/sign_out`](/reference/session/sign_out) | the session or the user to nothing | [`si.session.sign_out`](/reference/tools/si-session-sign_out) |  |
| [`/v1/session/whoami`](/reference/session/whoami) | a token, a key, or a run's identity to the caller, with its scopes and its access scopes | [`si.session.whoami`](/reference/tools/si-session-whoami) |  |
| [`/v1/session/sign_in`](/reference/session/sign_in) | nothing, or the tenant to sign in to to the way the browser was opened, then the caller as a view once the code came back; the refresh token goes to the keychain and never to the caller | [`si.session.sign_in`](/reference/tools/si-session-sign_in) |  |
| [`/v1/session/cache`](/reference/session/cache) | nothing, or a call to forget to what the app holds from earlier answers, by call and date, and when each expires | [`si.session.cache`](/reference/tools/si-session-cache) |  |
| [`/v1/ask/facts`](/reference/ask/facts) | a unit or a population, the date it was true, and the date we knew it, as two parameters. Both default to now to the facts, and the tier that gave them | [`si.ask.facts`](/reference/tools/si-ask-facts) |  |
| [`/v1/ask/get_content`](/reference/ask/get_content) | a `ContentRequest` to a `ContentResponse`, the page in bronze | [`si.ask.get_content`](/reference/tools/si-ask-get_content) | task |
| [`/v1/ask/groups`](/reference/ask/groups) | a scope, the two dates, and the resolution of the cut to the cluster response cards: each group with the share each layer of likeness contributed, its top communities, words and domains, its size and trend by month, and the proxies that placed its members | [`si.ask.groups`](/reference/tools/si-ask-groups) |  |
| [`/v1/ask/judge_fit`](/reference/ask/judge_fit) | Judges one entity against a buyer profile, and against a brand whose offerings' fit is in question to The answer gives the fit with each criterion and its highlights, the temperature with its reason, and the verdict. It makes no lead | [`si.ask.judge_fit`](/reference/tools/si-ask-judge_fit) |  |
| [`/v1/ask/keep_question`](/reference/ask/keep_question) | the question and its scope to a saved question | [`si.ask.keep_question`](/reference/tools/si-ask-keep_question) |  |
| [`/v1/ask/neighbours`](/reference/ask/neighbours) | an entity, one kind of connection, and the two dates to the members, one hop away, and whether the cap was reached | [`si.ask.neighbours`](/reference/tools/si-ask-neighbours) |  |
| [`/v1/ask/preview`](/reference/ask/preview) | a predicate or its hash, the place, the window, the speeds wanted, and the caller with the surface it calls from to the typed answer of section 2.3, as it fills | [`si.ask.preview`](/reference/tools/si-ask-preview) | task |
| [`/v1/ask/propose_template`](/reference/ask/propose_template) | a `ProposeTemplateInput` to a draft template with fields and evidence spans for the person to confirm | [`si.ask.propose_template`](/reference/tools/si-ask-propose_template) | task |
| [`/v1/ask/read_source`](/reference/ask/read_source) | the installed connector, the kind, a cursor to a page of source objects, the next cursor, the cells credited | [`si.ask.read_source`](/reference/tools/si-ask-read_source) | task |
| [`/v1/ask/saved_view`](/reference/ask/saved_view) | the view. Or the view and a caller to the definition. Or its rows, with when they were built | [`si.ask.saved_view`](/reference/tools/si-ask-saved_view) |  |
| [`/v1/ask/scrape`](/reference/ask/scrape) | a `ScrapeRequest` to a `ScrapeResult`, the rows as source objects with their evidence spans | [`si.ask.scrape`](/reference/tools/si-ask-scrape) | task |
| [`/v1/ask/search`](/reference/ask/search) | a `SearchRequest` to `SearchResult` rows, streamed as engines answer, credited to cells | [`si.ask.search`](/reference/tools/si-ask-search) | task |
| [`/v1/ask/semantic_search`](/reference/ask/semantic_search) | a text or a subject's vector, the model, a floor and a population to the units above the floor. With them: the model, the floor, the measured recall of quantized embeddings, and the tier | [`si.ask.semantic_search`](/reference/tools/si-ask-semantic_search) |  |
| [`/v1/ask/sql`](/reference/ask/sql) | a query, in a strategy to rows, with how many and whether a bound was reached | [`si.ask.sql`](/reference/tools/si-ask-sql) |  |
| [`/v1/ask/local`](/reference/ask/local) | a question in one of the ask tools' owning types, over the files the app may read to the card, answered by the app's own engine over its tenant's files, with the same foot | [`si.ask.local`](/reference/tools/si-ask-local) |  |
| [`/v1/read/attributes`](/reference/read/attributes) | a population and, where wanted, a window to the attributes its units carry, each with its plain name, the units that carry it, the value type read and up to three examples, most carried first, with the units read and in, and the partial answer when the budget ran out | [`si.read.attributes`](/reference/tools/si-read-attributes) |  |
| [`/v1/read/audience_map`](/reference/read/audience_map) | a brand, two facets or a facet and a community, the window to the shared subjects, the share, the lift, the negative control that bounds it, and the size as bounds | [`si.read.audience_map`](/reference/tools/si-read-audience_map) |  |
| [`/v1/read/basket`](/reference/read/basket) | the basket, and one subject, a set of subjects, a scope predicate or a cut into groups, with the window to the basket reading as a fact: memberships with their scale of association and likelihood for one subject; population readings and co-membership for a set; proxy against group with lift and control for groups | [`si.read.basket`](/reference/tools/si-read-basket) |  |
| [`/v1/read/board`](/reference/read/board) | the board and a period to the board with every tile's numbers, each with its basis and its population | [`si.read.board`](/reference/tools/si-read-board) |  |
| [`/v1/read/brand_design_system`](/reference/read/brand_design_system) | the brand, and a version, else the newest to the design system as it stands, with every basis | [`si.read.brand_design_system`](/reference/tools/si-read-brand_design_system) |  |
| [`/v1/read/brand_design_system_changes`](/reference/read/brand_design_system_changes) | the brand and two versions, else the two newest to every value that differs, by path, with the basis on each side, and the counts | [`si.read.brand_design_system_changes`](/reference/tools/si-read-brand_design_system_changes) |  |
| [`/v1/read/browse_view`](/reference/read/browse_view) | a `BrowseViewInput` to one frame of the page as the person sees it, with its size and address, for a dashboard that shows the session live and forwards the person's clicks and words as steps | [`si.read.browse_view`](/reference/tools/si-read-browse_view) |  |
| [`/v1/read/candidates`](/reference/read/candidates) | Reads the candidates of one brand, narrowed by a buyer profile or by a place to Each candidate arrives with the signals gathered about it, the rung it has reached, and what it still lacks to qualify | [`si.read.candidates`](/reference/tools/si-read-candidates) |  |
| [`/v1/read/capture_health`](/reference/read/capture_health) | a platform and a window, or nothing to captures by platform in the window against the window before, with a verdict | [`si.read.capture_health`](/reference/tools/si-read-capture_health) |  |
| [`/v1/read/capture_rules`](/reference/read/capture_rules) | a platform, or nothing to the rules with each platform's readiness | [`si.read.capture_rules`](/reference/tools/si-read-capture_rules) |  |
| [`/v1/read/catalogue`](/reference/read/catalogue) | a tenant or a brand to every source and connector with its kinds of reading and action, its state, the identity it needs, its cost, its rights, its coverage and its health | [`si.read.catalogue`](/reference/tools/si-read-catalogue) |  |
| [`/v1/read/chain`](/reference/read/chain) | a brand to its roles, its handovers and each handover's count with its instrument | [`si.read.chain`](/reference/tools/si-read-chain) |  |
| [`/v1/read/compare`](/reference/read/compare) | two brands, a question from the closed list of comparisons to two summaries over one structure, each with its coverage | [`si.read.compare`](/reference/tools/si-read-compare) |  |
| [`/v1/read/connectors`](/reference/read/connectors) | a tenant or a brand to every kind of reading and of action, by source, with its state, the identity it needs, its cost and its rights | [`si.read.connectors`](/reference/tools/si-read-connectors) |  |
| [`/v1/read/consent`](/reference/read/consent) | the person or tenant, and the use to a fact. Or yes or no, with the fact that decides | [`si.read.consent`](/reference/tools/si-read-consent) |  |
| [`/v1/read/coverage`](/reference/read/coverage) | a cell, or a scope of entities with a window to what has been read, when and how deep, in the three positions | [`si.read.coverage`](/reference/tools/si-read-coverage) |  |
| [`/v1/read/coverage_by_cell`](/reference/read/coverage_by_cell) | a source, or a scope with a window to measured, never measured with the reason, withheld | [`si.read.coverage_by_cell`](/reference/tools/si-read-coverage_by_cell) |  |
| [`/v1/read/document`](/reference/read/document) | the document, the version, the caller to the version, with when it was built and what it was built from | [`si.read.document`](/reference/tools/si-read-document) |  |
| [`/v1/read/document_changes`](/reference/read/document_changes) | two versions to every number that moved with its unit, every figure replaced | [`si.read.document_changes`](/reference/tools/si-read-document_changes) |  |
| [`/v1/read/effect`](/reference/read/effect) | a move, the window to the effect with its interval, or withheld with what would settle it | [`si.read.effect`](/reference/tools/si-read-effect) |  |
| [`/v1/read/entity`](/reference/read/entity) | an entity, and the two dates to every identifier it ever had, every account, everything it published, every thread, community and gathering, and every connection, across platforms and sources | [`si.read.entity`](/reference/tools/si-read-entity) |  |
| [`/v1/read/estimate`](/reference/read/estimate) | an estimator, the case to the estimate with its interval, its evidence and its familiarity, or withheld | [`si.read.estimate`](/reference/tools/si-read-estimate) |  |
| [`/v1/read/explain_catch`](/reference/read/explain_catch) | the match to the conditions that admitted it, the words each matched, the observation, and the source | [`si.read.explain_catch`](/reference/tools/si-read-explain_catch) |  |
| [`/v1/read/failed_calls`](/reference/read/failed_calls) | a tenant to every signed call that did not land, with why, and a way to send it again | [`si.read.failed_calls`](/reference/tools/si-read-failed_calls) |  |
| [`/v1/read/fit_frame`](/reference/read/fit_frame) | Reads the frame of one fit search to The answer gives the markets ranked, the offering sculpted for each buyer profile, the tactics proposed to test the fit, the verdict for each market, and the set of options that compares them | [`si.read.fit_frame`](/reference/tools/si-read-fit_frame) |  |
| [`/v1/read/fit_plays`](/reference/read/fit_plays) | Reads the tactics that fit one phase of the search, for a vertical or a kind of offering to The answer gives the tactics in the order to run them | [`si.read.fit_plays`](/reference/tools/si-read-fit_plays) |  |
| [`/v1/read/forecasts`](/reference/read/forecasts) | a play or a tactic, across brands to every forecast with its effect, how well the band held, and the proper score by play, tactic, kind of buyer, framing, actor and content | [`si.read.forecasts`](/reference/tools/si-read-forecasts) |  |
| [`/v1/read/grounding_priors`](/reference/read/grounding_priors) | a platform, or nothing (`GroundingPriorsInput`) to how often a person supported each kind of suggestion at each breadth, one row per kind, platform and breadth (`GroundingPriors`) | [`si.read.grounding_priors`](/reference/tools/si-read-grounding_priors) |  |
| [`/v1/read/groundings`](/reference/read/groundings) | one capture's, one entity's, or every grounding in a place to each grounding with its hypotheses | [`si.read.groundings`](/reference/tools/si-read-groundings) |  |
| [`/v1/read/instruction_set`](/reference/read/instruction_set) | nothing to the set at its current version, assembled | [`si.read.instruction_set`](/reference/tools/si-read-instruction_set) |  |
| [`/v1/read/intelligence`](/reference/read/intelligence) | a subject and a kind of intelligence to the kind's facts about the subject with their basis, their coverage and their date | [`si.read.intelligence`](/reference/tools/si-read-intelligence) |  |
| [`/v1/read/invitations`](/reference/read/invitations) | nothing to the invitations with their states | [`si.read.invitations`](/reference/tools/si-read-invitations) |  |
| [`/v1/read/invoices`](/reference/read/invoices) | a period, or nothing to the invoices with their states | [`si.read.invoices`](/reference/tools/si-read-invoices) |  |
| [`/v1/read/leads`](/reference/read/leads) | Reads the leads of one brand, narrowed by a place, a condition or a user to The answer gives the leads, or the package that holds them | [`si.read.leads`](/reference/tools/si-read-leads) |  |
| [`/v1/read/ledger`](/reference/read/ledger) | a strategy, the window to every move, action, forecast, effect and impact in order, with the budget spent by kind | [`si.read.ledger`](/reference/tools/si-read-ledger) |  |
| [`/v1/read/lineage`](/reference/read/lineage) | an artefact to its whole history and footprint, marking unavailable what a store cannot answer | [`si.read.lineage`](/reference/tools/si-read-lineage) |  |
| [`/v1/read/lookup`](/reference/read/lookup) | a key: a namespace with a value, or a name with a place, and with a name a breadth. And the two dates to the entity, or the possible matches, or nothing; with a breadth, the record's candidates by the one candidate search | [`si.read.lookup`](/reference/tools/si-read-lookup) |  |
| [`/v1/read/map`](/reference/read/map) | a brand, and the two dates to the map | [`si.read.map`](/reference/tools/si-read-map) |  |
| [`/v1/read/market`](/reference/read/market) | a brand, a segment, the window to the four stages, each with its count, value, basis and coverage, and the silent remainder | [`si.read.market`](/reference/tools/si-read-market) |  |
| [`/v1/read/market_twin`](/reference/read/market_twin) | Reads one market twin, and the date to read it as of to The answer gives the twin: the model family and template it was instanced from, the participants placed on the chain, the level of every stock as of the date, the simulations run on it in order, and the strategy whose armed plays are its interventions | [`si.read.market_twin`](/reference/tools/si-read-market_twin) |  |
| [`/v1/read/methods`](/reference/read/methods) | a question, or nothing to the methods that answer it, or every method, each with its readiness | [`si.read.methods`](/reference/tools/si-read-methods) |  |
| [`/v1/read/model_families`](/reference/read/model_families) | Reads the model families that fit a vertical or a representation to Each family arrives with what it represents, the substrate it is written over, its solver and its check | [`si.read.model_families`](/reference/tools/si-read-model_families) |  |
| [`/v1/read/monitor_strength`](/reference/read/monitor_strength) | the monitor and a window to the four numbers, each with its population | [`si.read.monitor_strength`](/reference/tools/si-read-monitor_strength) |  |
| [`/v1/read/page_changes`](/reference/read/page_changes) | a `PageChangesInput` to `PageChange` rows for the site or the watch in the window | [`si.read.page_changes`](/reference/tools/si-read-page_changes) |  |
| [`/v1/read/parameter`](/reference/read/parameter) | its name to its value, with its dimension and version | [`si.read.parameter`](/reference/tools/si-read-parameter) |  |
| [`/v1/read/plan_report`](/reference/read/plan_report) | a strategy and a window (`PlanReportInput`) to each play completed, partial or missing, and the items done off plan | [`si.read.plan_report`](/reference/tools/si-read-plan_report) |  |
| [`/v1/read/policy_replay`](/reference/read/policy_replay) | a policy row and its version, a strategy and a window (`PolicyReplayInput`) to what the policy would have chosen at every logged decision against what was chosen, and the effects that followed (`PolicyReplay`) | [`si.read.policy_replay`](/reference/tools/si-read-policy_replay) |  |
| [`/v1/read/posture`](/reference/read/posture) | a community, the window to open, conditional, closed or unknown, with the two removal rates and the archetype | [`si.read.posture`](/reference/tools/si-read-posture) |  |
| [`/v1/read/predicate_language`](/reference/read/predicate_language) | the register's name to its rows with the hash | [`si.read.predicate_language`](/reference/tools/si-read-predicate_language) |  |
| [`/v1/read/propensity`](/reference/read/propensity) | a lead, a move or a play, and which faces, actors or content or both (`PropensityInput`) to every eligible actor and every fitting content with the chance, its interval, its basis and the policy's odds, and the one the policy would choose (`PropensityAnswer`) | [`si.read.propensity`](/reference/tools/si-read-propensity) |  |
| [`/v1/read/proxy`](/reference/read/proxy) | the proxy and its version, the two dates, and a place to its members as a population, with the raw count, the estimate corrected by the recall and the undercount's interval, its calibration by segment, its coverage by channel, and its co-membership with other proxies; for an aggregate-only proxy the counts alone and never a member | [`si.read.proxy`](/reference/tools/si-read-proxy) |  |
| [`/v1/read/receipts`](/reference/read/receipts) | the kind, export or erasure to the receipts | [`si.read.receipts`](/reference/tools/si-read-receipts) |  |
| [`/v1/read/register`](/reference/read/register) | its name, and a version or *current* to its rows, and the hash | [`si.read.register`](/reference/tools/si-read-register) |  |
| [`/v1/read/registered`](/reference/read/registered) | a register and a name to the row, or nothing | [`si.read.registered`](/reference/tools/si-read-registered) |  |
| [`/v1/read/roles`](/reference/read/roles) | nothing, or one role to the register of roles: each role's side, what it does, what it hands on, which connection holds it, and whether its holder can be a lead | [`si.read.roles`](/reference/tools/si-read-roles) |  |
| [`/v1/read/scrape_runs`](/reference/read/scrape_runs) | a `ScrapeRunsInput` to `ScrapeRun` rows with pages, rows, bytes, cost and time | [`si.read.scrape_runs`](/reference/tools/si-read-scrape_runs) |  |
| [`/v1/read/signals`](/reference/read/signals) | a monitor, a subject, a kind or a strategy, and a window to the facts, with the coverage and the count not evaluable for the same window | [`si.read.signals`](/reference/tools/si-read-signals) |  |
| [`/v1/read/simulation_frame`](/reference/read/simulation_frame) | Reads the frame of one simulation to The answer gives the trajectory of every stock, the gain of every loop, the sensitivity to every intervention, and the set of options that compares strategies laid over the same template | [`si.read.simulation_frame`](/reference/tools/si-read-simulation_frame) |  |
| [`/v1/read/source_procedure`](/reference/read/source_procedure) | a source to its procedure at its version, the date of its last reading and whether it is stale | [`si.read.source_procedure`](/reference/tools/si-read-source_procedure) |  |
| [`/v1/read/speed_to_lead`](/reference/read/speed_to_lead) | Reads the delay from delivery to the first touch for one brand, over a window to The answer gives the measure's readings, with the population each was read over | [`si.read.speed_to_lead`](/reference/tools/si-read-speed_to_lead) |  |
| [`/v1/read/strategy`](/reference/read/strategy) | a strategy, as of a date (`StrategyReadInput`) to the `Strategy` with its life, its game, its graph of plays with each play's class and its reading, the experiments' shares and the frame of its last simulation | [`si.read.strategy`](/reference/tools/si-read-strategy) |  |
| [`/v1/read/systems_models`](/reference/read/systems_models) | Reads the systems models that fit one vertical or one kind of offering to Each template arrives with its readiness and the defect it carries named | [`si.read.systems_models`](/reference/tools/si-read-systems_models) |  |
| [`/v1/read/trajectory`](/reference/read/trajectory) | a strategy or one move, and a window (`TrajectoryInput`) to plan item to grounded move to outcome: each move with the items that carried it out, their readings and its effect | [`si.read.trajectory`](/reference/tools/si-read-trajectory) |  |
| [`/v1/read/under_test`](/reference/read/under_test) | a subject or a scope, and the two dates to every hypothesis about it with its standing, its evidence for and against, the tests run and the tests owed, and what would settle each | [`si.read.under_test`](/reference/tools/si-read-under_test) |  |
| [`/v1/read/unit`](/reference/read/unit) | the kind, the id, the caller to the unit | [`si.read.unit`](/reference/tools/si-read-unit) |  |
| [`/v1/read/usage_statement`](/reference/read/usage_statement) | a period to the tenant's usage of the period by kind, priced, against the plan | [`si.read.usage_statement`](/reference/tools/si-read-usage_statement) |  |
| [`/v1/read/value_chain`](/reference/read/value_chain) | Reads the value chain of one vertical, with the brand whose participants are placed on it to The answer gives the chain's stocks and handovers with their counts, the participants on each stock, and the loops the templates name over it | [`si.read.value_chain`](/reference/tools/si-read-value_chain) |  |
| [`/v1/read/vertical`](/reference/read/vertical) | the vertical, or a brand whose vertical is meant to its chain by side with every stock's count and basis, its roles, its segments, its templates, its words and its rules | [`si.read.vertical`](/reference/tools/si-read-vertical) |  |
| [`/v1/read/why`](/reference/read/why) | any unit to the chain of reasons, from this unit back to its first cause | [`si.read.why`](/reference/tools/si-read-why) |  |
| [`/v1/read/withheld`](/reference/read/withheld) | Reads the withheld count for one brand or one tenant to The answer gives the count by buyer profile and temperature, with the period and the limit it was read against | [`si.read.withheld`](/reference/tools/si-read-withheld) |  |
| [`/v1/view/capabilities`](/reference/view/capabilities) | nothing to the page | [`si.view.capabilities`](/reference/tools/si-view-capabilities) |  |
| [`/v1/view/journey`](/reference/view/journey) | a unit's id to its hops, back and forward | [`si.view.journey`](/reference/tools/si-view-journey) |  |
| [`/v1/view/oldest`](/reference/view/oldest) | a kind, a place, and how many to those units, each with its reason and since when | [`si.view.oldest`](/reference/tools/si-view-oldest) |  |
| [`/v1/view/pairings`](/reference/view/pairings) | a scope to each pairing, with the units that lack their pair | [`si.view.pairings`](/reference/tools/si-view-pairings) |  |
| [`/v1/view/stocks`](/reference/view/stocks) | a part, a kind or a place, and a scope the caller holds to the six numbers for each | [`si.view.stocks`](/reference/tools/si-view-stocks) |  |
| [`/v1/view/usage`](/reference/view/usage) | a tenant, a kind, a provider, a window to quantity and cost by kind, by tenant, by provider and by period, with each provider's reconciliation state | [`si.view.usage`](/reference/tools/si-view-usage) |  |
| [`/v1/view/waiting`](/reference/view/waiting) | the caller to notifications, oldest first. Or nothing | [`si.view.waiting`](/reference/tools/si-view-waiting) |  |
| [`/v1/act/act_through_connector`](/reference/act/act_through_connector) | the installed connector, the kind, the arguments with their sources to a move, proposed or running by the grant's mode; then the source's own id for what was done | [`si.act.act_through_connector`](/reference/tools/si-act-act_through_connector) | task |
| [`/v1/act/annotate`](/reference/act/annotate) | an `Annotation` with the target *an entity* and the entity's id, from the web shell, the desktop shell, the agent or the API; in the side panel the same type travels inside the page's reading to the fact the person stated, a claim or a connection, by its id and kind (`UnitRef`) | [`si.act.annotate`](/reference/tools/si-act-annotate) |  |
| [`/v1/act/arm_monitor`](/reference/act/arm_monitor) | the monitor's version, and for arming the preview it was judged by to the monitor's new state | [`si.act.arm_monitor`](/reference/tools/si-act-arm_monitor) |  |
| [`/v1/act/arm_play`](/reference/act/arm_play) | a strategy, the play and its version, the goal it serves, and the share it is armed on with its holdout (a share under one makes the play an experiment) to the armed play with its class proposed from the kind's usual class and the rivals' coverage, and the demand cells it raised | [`si.act.arm_play`](/reference/tools/si-act-arm_play) |  |
| [`/v1/act/assign`](/reference/act/assign) | Assigns one lead to one user by hand, or hands it on to The answer gives the assignment, with the person who made it as its reason | [`si.act.assign`](/reference/tools/si-act-assign) |  |
| [`/v1/act/beat`](/reference/act/beat) | what runs, and when to the beat | [`si.act.beat`](/reference/tools/si-act-beat) |  |
| [`/v1/act/bind_buyer`](/reference/act/bind_buyer) | the kind, an offering or a segment, the weight, the mode to the binding, and the preview of the kind's members | [`si.act.bind_buyer`](/reference/tools/si-act-bind_buyer) |  |
| [`/v1/act/board`](/reference/act/board) | the board with its tiles to the board, ready, or not ready with the tile that could not be drawn | [`si.act.board`](/reference/tools/si-act-board) |  |
| [`/v1/act/browse_step`](/reference/act/browse_step) | a `BrowseStepInput` to the step's result: the accessibility tree, the text, the markdown, a screenshot's hash, or a download set | [`si.act.browse_step`](/reference/tools/si-act-browse_step) | task |
| [`/v1/act/build_document`](/reference/act/build_document) | the document, the two dates, which default to now to the build, then the version, or not ready with every number that is missing | [`si.act.build_document`](/reference/tools/si-act-build_document) | task |
| [`/v1/act/capacity`](/reference/act/capacity) | Sets how many new leads one user can take in a period to The answer gives the new capacity, with how many the user holds and when it refills | [`si.act.capacity`](/reference/tools/si-act-capacity) |  |
| [`/v1/act/capture`](/reference/act/capture) | the document, the network events, the address, the person's identity to the capture with its source objects and the cells credited | [`si.act.capture`](/reference/tools/si-act-capture) |  |
| [`/v1/act/capture_rule`](/reference/act/capture_rule) | the rule to the rule, ready or not ready with the reason | [`si.act.capture_rule`](/reference/tools/si-act-capture_rule) |  |
| [`/v1/act/change_plan`](/reference/act/change_plan) | the plan kind to the change as a proposal, and the provider's own page for payment | [`si.act.change_plan`](/reference/tools/si-act-change_plan) |  |
| [`/v1/act/correct`](/reference/act/correct) | the id of the wrong event, and the right facts to a correcting event | [`si.act.correct`](/reference/tools/si-act-correct) |  |
| [`/v1/act/crawl`](/reference/act/crawl) | a `ScrapeRequest` whose scope names the site's seeds, with sitemap-driven discovery on to the `ScrapeRun`, queued, or the run that already stands for the same template version and scope inside its freshness; every page lands as a capture through the one pipeline, and each page that could not be read is a gap with its reason | [`si.act.crawl`](/reference/tools/si-act-crawl) | task |
| [`/v1/act/decide_ask`](/reference/act/decide_ask) | the ask, by a user who may to the ask, approved or declined | [`si.act.decide_ask`](/reference/tools/si-act-decide_ask) |  |
| [`/v1/act/decide_brand_design`](/reference/act/decide_brand_design) | the brand, the value's path, the decision (accepted, declined, changed) and, when changed, the tenant's own value, with the reason to the decision as a fact at brand scope: the brand's memory, read by the merge, so a changed value stands as stated by the tenant until the site changes and a declined one is never proposed again | [`si.act.decide_brand_design`](/reference/tools/si-act-decide_brand_design) |  |
| [`/v1/act/decide_move`](/reference/act/decide_move) | the move, the caller to the move in its new place, with who moved it | [`si.act.decide_move`](/reference/tools/si-act-decide_move) |  |
| [`/v1/act/deepen`](/reference/act/deepen) | an observation, and the depth: fetched in full, or given meaning to a deepening | [`si.act.deepen`](/reference/tools/si-act-deepen) | task |
| [`/v1/act/dry_run`](/reference/act/dry_run) | an action to what it would do, and what the inverse would be | [`si.act.dry_run`](/reference/tools/si-act-dry_run) |  |
| [`/v1/act/erase_person`](/reference/act/erase_person) | the person to the erasure as work, then its receipt | [`si.act.erase_person`](/reference/tools/si-act-erase_person) | task |
| [`/v1/act/export_tenant`](/reference/act/export_tenant) | nothing to the export as work, then its receipt | [`si.act.export_tenant`](/reference/tools/si-act-export_tenant) | task |
| [`/v1/act/goal`](/reference/act/goal) | a strategy, a measure, a target, a window to the goal, naming the measure's version | [`si.act.goal`](/reference/tools/si-act-goal) |  |
| [`/v1/act/grant`](/reference/act/grant) | the grant, by a caller who may give it to the grant's new version | [`si.act.grant`](/reference/tools/si-act-grant) |  |
| [`/v1/act/ground`](/reference/act/ground) | exactly one of a capture, an entity, a text or an address, and a breadth (`GroundInput`) to the grounding with its hypotheses (`GroundingAnswer`), the channels that ran and the ones not ready with their reason | [`si.act.ground`](/reference/tools/si-act-ground) |  |
| [`/v1/act/hold_identity`](/reference/act/hold_identity) | the platform, the scopes the rows declare to a browser session for the person; then the credential with its vault entry | [`si.act.hold_identity`](/reference/tools/si-act-hold_identity) |  |
| [`/v1/act/install_connector`](/reference/act/install_connector) | the connector, the ways chosen, and the identity for each to an installed connector, ready or not ready with its reason | [`si.act.install_connector`](/reference/tools/si-act-install_connector) |  |
| [`/v1/act/install_pack`](/reference/act/install_pack) | a brand, the pack and its version to the copies made, each naming its origin | [`si.act.install_pack`](/reference/tools/si-act-install_pack) |  |
| [`/v1/act/invite`](/reference/act/invite) | an address and a role to the invitation, open, with its expiry | [`si.act.invite`](/reference/tools/si-act-invite) |  |
| [`/v1/act/keep_basket`](/reference/act/keep_basket) | its name, its scope and its proxies by version to the basket with its version, not ready while any proxy is | [`si.act.keep_basket`](/reference/tools/si-act-keep_basket) |  |
| [`/v1/act/keep_buyer`](/reference/act/keep_buyer) | the whole profile as it should stand next, with its predicate's tree given in full, its bindings and its ladder to the profile as its next version, ready, or not ready with the compiler's reason; the predicate kept by its hash | [`si.act.keep_buyer`](/reference/tools/si-act-keep_buyer) |  |
| [`/v1/act/keep_ladder`](/reference/act/keep_ladder) | its ordered rungs, each a predicate over the population, and the rung that qualifies; the rungs' predicates in full where they are not yet kept to the ladder with its version, not ready while a rung's predicate is not kept or does not compile | [`si.act.keep_ladder`](/reference/tools/si-act-keep_ladder) |  |
| [`/v1/act/keep_monitor`](/reference/act/keep_monitor) | its name, its predicate, the place it runs at, the kind of signal it makes, the strategy where one is chosen, and for a platform monitor the vertical to the monitor with its version, not armed; not ready while its predicate does not compile at its place, with the reasons from compile | [`si.act.keep_monitor`](/reference/tools/si-act-keep_monitor) |  |
| [`/v1/act/keep_play`](/reference/act/keep_play) | a play for a brand, written once by the platform as an original or by the tenant: its goal, its condition as a predicate over its population, its class, its tactic, the move it proposes, its measure, its window, its forecast rule, its comparison, when it stops, and its graph of moves as edges (`KeepPlayInput`); the predicates given in full are kept by their hashes in the same call to the play as the next version of its name under the brand, ready, or not ready with the first reason: *the condition does not compile*, *the graph has a cycle* naming the edge, *an edge cannot be evaluated* naming the edge and the population, *an edge is neither always nor guarded* | [`si.act.keep_play`](/reference/tools/si-act-keep_play) |  |
| [`/v1/act/keep_proxy`](/reference/act/keep_proxy) | a proxy: its name, the facet kind it stands for, its scope, its rule as a predicate, its strength, its named control, its failure mode, and whether it is aggregate-only to the proxy with its version by hash, not ready until its controls have run and its calibration is read | [`si.act.keep_proxy`](/reference/tools/si-act-keep_proxy) |  |
| [`/v1/act/make_brand_design_system`](/reference/act/make_brand_design_system) | the brand, and the site when it is not the brand row's own to the brand's design system as the next version of its name: every colour, face, size, step, radius, shadow and the logo, each measured, inferred by a named rule or never measured, with the artefacts it was read from and the gaps; and the same values in the platform's token shape | [`si.act.make_brand_design_system`](/reference/tools/si-act-make_brand_design_system) |  |
| [`/v1/act/make_market_twin`](/reference/act/make_market_twin) | Makes one market twin from a vertical, a segment, a brand, a template and the way of going to market it serves to The answer gives the twin, ready or not ready with the stock the record cannot read named | [`si.act.make_market_twin`](/reference/tools/si-act-make_market_twin) |  |
| [`/v1/act/map_brand`](/reference/act/map_brand) | a web address, and the brand scope to hold the map to the map as it stands, with every part measured or never measured, and the demand raised | [`si.act.map_brand`](/reference/tools/si-act-map_brand) | task |
| [`/v1/act/mark_lead`](/reference/act/mark_lead) | Marks a condition on one lead, with a reason where the condition asks for one to The answer gives the lead's new outcome | [`si.act.mark_lead`](/reference/tools/si-act-mark_lead) |  |
| [`/v1/act/mark_rival`](/reference/act/mark_rival) | a brand, the rival's entity, the evidence to the fact | [`si.act.mark_rival`](/reference/tools/si-act-mark_rival) |  |
| [`/v1/act/membership`](/reference/act/membership) | the person's address, and the roles with where each is held to the membership | [`si.act.membership`](/reference/tools/si-act-membership) |  |
| [`/v1/act/move_strategy`](/reference/act/move_strategy) | a strategy, the place to move it to and the reason (`StrategyMoveInput`): drafted, simulated, rolled out in part, running, paused, ended to the `Strategy` in its new place, with who moved it | [`si.act.move_strategy`](/reference/tools/si-act-move_strategy) |  |
| [`/v1/act/notification_channel`](/reference/act/notification_channel) | Writes one notification channel, which is where a notice goes to The channel is ready once its test notice is acknowledged. Until then it is not ready, with the reason | [`si.act.notification_channel`](/reference/tools/si-act-notification_channel) |  |
| [`/v1/act/notification_rule`](/reference/act/notification_rule) | Writes one notification rule, which says who is told and never what happens to The answer gives the rule, with the next notice it will send | [`si.act.notification_rule`](/reference/tools/si-act-notification_rule) |  |
| [`/v1/act/parameter`](/reference/act/parameter) | a parameter by its name, its value and its scope to the parameter as written, at its new version | [`si.act.parameter`](/reference/tools/si-act-parameter) |  |
| [`/v1/act/place_participant`](/reference/act/place_participant) | Places one party in one role on one stock of a vertical's chain, with the evidence for it to The answer gives the participant, ready or not ready with the reason | [`si.act.place_participant`](/reference/tools/si-act-place_participant) |  |
| [`/v1/act/probe_identity`](/reference/act/probe_identity) | the identity to its readiness with the reason | [`si.act.probe_identity`](/reference/tools/si-act-probe_identity) |  |
| [`/v1/act/propose_move`](/reference/act/propose_move) | a match of a play to the move, proposed, with its forecast and its assignments as facts | [`si.act.propose_move`](/reference/tools/si-act-propose_move) |  |
| [`/v1/act/publish`](/reference/act/publish) | the version, the address, the visibility to the publishing, proposed or published, and its receipt | [`si.act.publish`](/reference/tools/si-act-publish) |  |
| [`/v1/act/raise_need`](/reference/act/raise_need) | a cell's key, the reason and the value to the cell, wanted | [`si.act.raise_need`](/reference/tools/si-act-raise_need) |  |
| [`/v1/act/record_fit_reading`](/reference/act/record_fit_reading) | Records one result of a person's own test: the tactic, the market, the measure, its value, the sample and where it came from to The answer gives the reading as a fact the record keeps | [`si.act.record_fit_reading`](/reference/tools/si-act-record_fit_reading) |  |
| [`/v1/act/remember`](/reference/act/remember) | a memory and its scope to the memory, or a later fact that ends it | [`si.act.remember`](/reference/tools/si-act-remember) |  |
| [`/v1/act/routing`](/reference/act/routing) | Writes, previews or arms a routing rule from a predicate and the people or the team it attaches to A write or an arm gives the rule. A preview gives the leads it would have admitted and who would have had them, read over history | [`si.act.routing`](/reference/tools/si-act-routing) |  |
| [`/v1/act/run_action`](/reference/act/run_action) | an action prepared by a move to the action, allowed or not allowed with the reason, then running, then done or failed | [`si.act.run_action`](/reference/tools/si-act-run_action) | task |
| [`/v1/act/scrape_template`](/reference/act/scrape_template) | a `TemplateInput` to the template, ready or not ready with the reason; for a preview, the rows from its samples and a bounded live scope | [`si.act.scrape_template`](/reference/tools/si-act-scrape_template) |  |
| [`/v1/act/seed_tenant`](/reference/act/seed_tenant) | the manifest and the window to the seed as work, then its receipt with counts by kind and what is not ready | [`si.act.seed_tenant`](/reference/tools/si-act-seed_tenant) | task |
| [`/v1/act/set_aside_run`](/reference/act/set_aside_run) | a `SetAsideRunInput`: the run's key and a person's plain reason to the `ScrapeRun`, kept in the parked place with the reason, which the beat never takes up; each move is an event with the reason | [`si.act.set_aside_run`](/reference/tools/si-act-set_aside_run) |  |
| [`/v1/act/settle`](/reference/act/settle) | a hypothesis, the standing, the caller to the hypothesis settled, with who settled it and on what | [`si.act.settle`](/reference/tools/si-act-settle) |  |
| [`/v1/act/settle_match`](/reference/act/settle_match) | the possible match, and a user's answer or a proof to confirmed, with the merge. Or rejected | [`si.act.settle_match`](/reference/tools/si-act-settle_match) |  |
| [`/v1/act/sign_up`](/reference/act/sign_up) | the company's name, and its domain where known, from a signed-in person who belongs to no tenant to the tenant, made on the trial plan with the person as its first member and owner, in one transaction with its events | [`si.act.sign_up`](/reference/tools/si-act-sign_up) |  |
| [`/v1/act/strategy`](/reference/act/strategy) | a brand or brands, a name, a window if any to the strategy, with the standing measures | [`si.act.strategy`](/reference/tools/si-act-strategy) |  |
| [`/v1/act/sync_rule`](/reference/act/sync_rule) | the installed connector, the offer, the fields of section 2.8 to the rule; for a preview, what it would read and push | [`si.act.sync_rule`](/reference/tools/si-act-sync_rule) |  |
| [`/v1/act/undo`](/reference/act/undo) | a done action to the action, undone, and the inverse's own action | [`si.act.undo`](/reference/tools/si-act-undo) |  |
| [`/v1/act/undo_action`](/reference/act/undo_action) | the move to the inverse move | [`si.act.undo_action`](/reference/tools/si-act-undo_action) |  |
| [`/v1/act/undo_merge`](/reference/act/undo_merge) | the merge or the decision, and the reason to a parting. Or a later decision, with the facts written again | [`si.act.undo_merge`](/reference/tools/si-act-undo_merge) |  |
| [`/v1/act/watch`](/reference/act/watch) | a public entity to a watched identity, with its monitor armed | [`si.act.watch`](/reference/tools/si-act-watch) |  |
| [`/v1/act/watch_site`](/reference/act/watch_site) | a `WatchSiteInput` to the watch, ready or not ready; for a preview, the pages it would read and the changes it would have raised over the window | [`si.act.watch_site`](/reference/tools/si-act-watch_site) |  |
| [`/v1/act/webhook`](/reference/act/webhook) | the address, what to be told about, and a secret to sign with to the row | [`si.act.webhook`](/reference/tools/si-act-webhook) |  |
| [`/v1/act/weigh`](/reference/act/weigh) | a hypothesis, and a fact or a test's reading to the hypothesis with the evidence attached and its standing recomputed against its bar | [`si.act.weigh`](/reference/tools/si-act-weigh) |  |
| [`/v1/act/withdraw`](/reference/act/withdraw) | a publishing to the publishing, withdrawn | [`si.act.withdraw`](/reference/tools/si-act-withdraw) |  |
| [`/v1/act/workflow`](/reference/act/workflow) | its steps and what starts it to the workflow, and for a preview what it would have done over history, acting on nothing | [`si.act.workflow`](/reference/tools/si-act-workflow) |  |
| [`/v1/work/backfill`](/reference/work/backfill) | a source, an access method, a window, a plane to the job; then partitions carrying the window | [`si.work.backfill`](/reference/tools/si-work-backfill) | task |
| [`/v1/work/browse_open`](/reference/work/browse_open) | a `BrowseOpenInput` to the session, opened, with its live view | [`si.work.browse_open`](/reference/tools/si-work-browse_open) | task |
| [`/v1/work/browse_take_over`](/reference/work/browse_take_over) | a `BrowseTakeOverInput` to the session, driven by the person or handed back | [`si.work.browse_take_over`](/reference/tools/si-work-browse_take_over) |  |
| [`/v1/work/build_facet`](/reference/work/build_facet) | a facet kind, a seed (a predicate, a list of communities, or a place from the gazetteer), the scope, and the positive and negative controls to the facet's register with every candidate kept or dropped and its reason in words, its people, its pairs and its trend, and the facet not ready until its calibration is read | [`si.work.build_facet`](/reference/tools/si-work-build_facet) | task |
| [`/v1/work/cancel`](/reference/work/cancel) | the preview to nothing | [`si.work.cancel`](/reference/tools/si-work-cancel) |  |
| [`/v1/work/download_set`](/reference/work/download_set) | a `DownloadInput` to `DownloadJob` rows, one per file | [`si.work.download_set`](/reference/tools/si-work-download_set) | task |
| [`/v1/work/download_set_control`](/reference/work/download_set_control) | a `DownloadControlInput` to the jobs in their new place | [`si.work.download_set_control`](/reference/tools/si-work-download_set_control) |  |
| [`/v1/work/lay_strategy`](/reference/work/lay_strategy) | Lays one strategy on one twin, with the bounds of the run to The call returns the simulation whose interventions are the strategy's armed plays, then the frame | [`si.work.lay_strategy`](/reference/tools/si-work-lay_strategy) | task |
| [`/v1/work/mine`](/reference/work/mine) | the caller to every run the caller started that is still running, each with what it has done, whether it may be stopped, and the tool that stops it | [`si.work.mine`](/reference/tools/si-work-mine) |  |
| [`/v1/work/run_procedure`](/reference/work/run_procedure) | the procedure and its inputs to a task | [`si.work.run_procedure`](/reference/tools/si-work-run_procedure) | task |
| [`/v1/work/search_fit`](/reference/work/search_fit) | Searches for product-market fit from one end: an offering looking for its markets, or a concept looking for a market to The call returns the search as work, then the frame that holds what it settled | [`si.work.search_fit`](/reference/tools/si-work-search_fit) | task |
| [`/v1/work/simulate_market`](/reference/work/simulate_market) | Runs one systems model template over a market, with the interventions to try and the bounds of the run to The call returns the simulation as work, then the frame that holds what it reached | [`si.work.simulate_market`](/reference/tools/si-work-simulate_market) | task |
| [`/v1/work/status`](/reference/work/status) | the task to its progress. Or nothing | [`si.work.status`](/reference/tools/si-work-status) |  |
| [`/v1/work/local_procedure`](/reference/work/local_procedure) | a named procedure whose inputs are files in the workspace to a task run by the app with its steps in the app's own journal, resumable | [`si.work.local_procedure`](/reference/tools/si-work-local_procedure) | task |
| [`/v1/harness/delegate`](/reference/harness/delegate) | words, in a strategy to response cards, as they come, and a task where the work goes on | [`si.harness.delegate`](/reference/tools/si-harness-delegate) | task |
| [`/v1/files/download`](/reference/files/download) | a file's pointer from a task or a document, and where in the workspace to put it to progress by bytes moved of bytes in all, then the path inside the workspace | [`si.files.download`](/reference/tools/si-files-download) | task |
| [`/v1/files/upload`](/reference/files/upload) | a path inside the workspace, and what the file is for to progress, then the pointer the platform kept | [`si.files.upload`](/reference/tools/si-files-upload) | task |
| [`/v1/files/list`](/reference/files/list) | a path inside the workspace, or nothing to the files with their sizes, kinds and when they were written | [`si.files.list`](/reference/tools/si-files-list) |  |
| [`/v1/files/workspace`](/reference/files/workspace) | nothing, or a folder to make the workspace to the workspace folder, and every act the app made in it on the ledger | [`si.files.workspace`](/reference/tools/si-files-workspace) |  |
| [`/v1/economics/benchmarks`](/reference/economics/benchmarks) | a driver, and a population or a buyer profile to the benchmarks that apply, each with its interval, population, period, source and what its rights allow | [`si.economics.benchmarks`](/reference/tools/si-economics-benchmarks) |  |
| [`/v1/economics/estimate`](/reference/economics/estimate) | `EstimateReturnInput`: the buyer (an entity, a lead, a buyer profile or a session), the offering or tier, the stated numbers, and whether to simulate to a `Card` whose body is a `FrameOfASale` | [`si.economics.estimate`](/reference/tools/si-economics-estimate) |  |
| [`/v1/economics/ladder`](/reference/economics/ladder) | nothing, or a version to the price ladder in force with its study | [`si.economics.ladder`](/reference/tools/si-economics-ladder) |  |
| [`/v1/economics/models`](/reference/economics/models) | a vertical, a segment or a buyer profile to the business models that apply, each with its readiness, its drivers and its outputs | [`si.economics.models`](/reference/tools/si-economics-models) |  |
| [`/v1/economics/offer`](/reference/economics/offer) | `ReadingOfferedInput`: the buyer profile, the model, the drivers to ask to the reading offered, ready or not ready with the reason, and its page's address | [`si.economics.offer`](/reference/tools/si-economics-offer) |  |
| [`/v1/economics/study`](/reference/economics/study) | `PricingStudyInput`: the methods to run, the buyer profiles, the rivals' window to the study as a fact and its candidate ladders as a set of options | [`si.economics.study`](/reference/tools/si-economics-study) | task |



## Envelope, errors and limits
Every call is `POST /v1/<family>/<verb>`. Its JSON body is the serialisation of one owning type. Four headers go with every call. They carry the key, the scope, the date when the facts must have been true, and the date when the platform must have known them. Every response is a card with its foot. Every response also carries the contract's hash in the `Scale-Contract` header, and the platform reports a mismatch to a client whose hash differs. A long step returns status 202 with a task. The [envelope page](/reference/envelope) describes each part.


---
title: "The envelope, errors, limits, auth and versioning"
description: "Every call carries four headers, and every response is a card, a task or an error. This page describes the headers, the card and its foot, the error shape, the task for a long step, keys and grants, and the contract's version."
section: reference
address: /reference/envelope
contract: 0476e35e6e275db5
---

# The envelope, errors, limits, auth and versioning

Every call carries four headers, and every response is a card, a task or an error. This page describes the headers, the card and its foot, the error shape, the task for a long step, keys and grants, and the contract's version.

[figure: Every call carries the same envelope, and every response carries the contract's hash.]

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



## Card
Every successful response is a card. The card's body is the type that the route specifies. The card's foot states the basis of every number, the scope of the call and the two dates. The basis is one of four: the platform observed the number, a source stated it, a rule derived it, or the platform estimated it with an interval. The platform cannot build a card without its foot.

## Errors
Every failure returns the same error shape. The error carries a reason that a person can read, the kind of rejection, and the identifier of the rejected object. A reached limit, a disallowed scope, an invalid body and an object that is not ready each have their own kind.

## Limits and pages
Every list returns its items in pages, under a bound that the plan sets. Each page carries the cursor of the next page. The API gateway sets the rate limit for each key.

## Authentication and entitlement
You make a key in the platform's settings. A key carries grants from this set: read, ask, act, work, files and admin. Every route states the grant that it needs and the rung of scope that it runs at. The platform checks the plan's lead limit at delivery and not at acquisition. The platform counts and shows every lead that the plan withholds.

## Versioning
Every route starts with `/v1/`. Every response carries the contract's hash in the `Scale-Contract` header. This site is built from contract 0476e35e6e275db5cc06c238bc65f93c6070e2723b94b2b8dd78a66ec5306c3a, fixed on 2026-09-30. `POST /v1/contract` returns the served description of the contract.


---
title: "session: my grants"
description: "the caller, and a place to its permissions there, after all three narrowings"
section: reference
address: /reference/session/my_grants
contract: 0476e35e6e275db5
---

# session: my grants

the caller, and a place to its permissions there, after all three narrowings

[figure: The caller sends GrantsInput to /v1/session/my_grants. The platform returns a card whose body is [GrantRef].]

<span class="op-method">POST</span><span class="op-path">/v1/session/my_grants</span>

What may this caller do. The call needs the user rung under a token with the read grant, and it is served by the platform.

The route takes [GrantsInput](/concepts/grantsinput) and returns a card whose body is [GrantRef](/concepts/grantref).



## Request body
The request body is [GrantsInput](/concepts/grantsinput).



| field | type | required | note |
|---|---|---|---|
| `place` | [Scope](/concepts/scope) | yes |  |



## Response
The route returns a card whose body is [GrantRef](/concepts/grantref). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the user rung and a token with the read grant. The platform serves this route.

## Example
The example sends the smallest body that GrantsInput allows. The build validates it against the schema of GrantsInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/session/my_grants \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "place": { "level": "shared" } }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.session.my_grants({
    "place": {
      "level": "shared"
    }
  });
// answer.body is a [GrantRef]. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/session/my_grants",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "place": {
        "level": "shared"
      }
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/session/my_grants")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&GrantsInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.session.my_grants` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/GrantRef`. The [tool's page](/reference/tools/si-session-my_grants) describes it.


---
title: "session: my scopes"
description: "the caller to the scopes it reads, set on the database transaction before any query runs"
section: reference
address: /reference/session/my_scopes
contract: 0476e35e6e275db5
---

# session: my scopes

the caller to the scopes it reads, set on the database transaction before any query runs

[figure: The caller sends Nothing to /v1/session/my_scopes. The platform returns a card whose body is [Scope].]

<span class="op-method">POST</span><span class="op-path">/v1/session/my_scopes</span>

What may this caller read. The call needs the user rung under a token with the read grant, and it is served by the platform.

The route takes an empty body and returns a card whose body is [Scope](/concepts/scope).



## Request body
The request body is empty.



## Response
The route returns a card whose body is [Scope](/concepts/scope). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the user rung and a token with the read grant. The platform serves this route.

## Example
The example sends an empty body.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/session/my_scopes \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{}'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.session.my_scopes({});
// answer.body is a [Scope]. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/session/my_scopes",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={}).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/session/my_scopes")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&()).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.session.my_scopes` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Scope`. The [tool's page](/reference/tools/si-session-my_scopes) describes it.


---
title: "Every MCP tool, resource and prompt"
description: "The MCP server declares 195 tools, 4 resources and 2 prompts at contract 0476e35e6e275db5. It also supports the tasks, apps and elicitation extensions."
section: reference
address: /reference/tools
contract: 0476e35e6e275db5
---

# Every MCP tool, resource and prompt

The MCP server declares 195 tools, 4 resources and 2 prompts at contract 0476e35e6e275db5. It also supports the tasks, apps and elicitation extensions.

[figure: Every tool belongs to one family.]

The server implements MCP version 2026-07-28. Every tool, resource and prompt below is declared in the manifest the server publishes.

## Tools


| tool | purpose | read-only |
|---|---|---|
| [`si.session.my_grants`](/reference/tools/si-session-my_grants) | the caller, and a place | yes |
| [`si.session.my_scopes`](/reference/tools/si-session-my_scopes) | the caller | yes |
| [`si.session.sign_out`](/reference/tools/si-session-sign_out) | the session or the user | yes |
| [`si.session.whoami`](/reference/tools/si-session-whoami) | a token, a key, or a run's identity | yes |
| [`si.session.sign_in`](/reference/tools/si-session-sign_in) | nothing, or the tenant to sign in to | yes |
| [`si.session.cache`](/reference/tools/si-session-cache) | nothing, or a call to forget | yes |
| [`si.ask.facts`](/reference/tools/si-ask-facts) | a unit or a population, the date it was true, and the date we knew it, as two parameters. Both default to now | yes |
| [`si.ask.get_content`](/reference/tools/si-ask-get_content) | a `ContentRequest` | yes |
| [`si.ask.groups`](/reference/tools/si-ask-groups) | a scope, the two dates, and the resolution of the cut | yes |
| [`si.ask.judge_fit`](/reference/tools/si-ask-judge_fit) | Judges one entity against a buyer profile, and against a brand whose offerings' fit is in question | yes |
| [`si.ask.keep_question`](/reference/tools/si-ask-keep_question) | the question and its scope | yes |
| [`si.ask.neighbours`](/reference/tools/si-ask-neighbours) | an entity, one kind of connection, and the two dates | yes |
| [`si.ask.preview`](/reference/tools/si-ask-preview) | a predicate or its hash, the place, the window, the speeds wanted, and the caller with the surface it calls from | yes |
| [`si.ask.propose_template`](/reference/tools/si-ask-propose_template) | a `ProposeTemplateInput` | yes |
| [`si.ask.read_source`](/reference/tools/si-ask-read_source) | the installed connector, the kind, a cursor | yes |
| [`si.ask.saved_view`](/reference/tools/si-ask-saved_view) | the view. Or the view and a caller | yes |
| [`si.ask.scrape`](/reference/tools/si-ask-scrape) | a `ScrapeRequest` | yes |
| [`si.ask.search`](/reference/tools/si-ask-search) | a `SearchRequest` | yes |
| [`si.ask.semantic_search`](/reference/tools/si-ask-semantic_search) | a text or a subject's vector, the model, a floor and a population | yes |
| [`si.ask.sql`](/reference/tools/si-ask-sql) | a query, in a strategy | yes |
| [`si.ask.local`](/reference/tools/si-ask-local) | a question in one of the ask tools' owning types, over the files the app may read | yes |
| [`si.read.attributes`](/reference/tools/si-read-attributes) | a population and, where wanted, a window | yes |
| [`si.read.audience_map`](/reference/tools/si-read-audience_map) | a brand, two facets or a facet and a community, the window | yes |
| [`si.read.basket`](/reference/tools/si-read-basket) | the basket, and one subject, a set of subjects, a scope predicate or a cut into groups, with the window | yes |
| [`si.read.board`](/reference/tools/si-read-board) | the board and a period | yes |
| [`si.read.brand_design_system`](/reference/tools/si-read-brand_design_system) | the brand, and a version, else the newest | yes |
| [`si.read.brand_design_system_changes`](/reference/tools/si-read-brand_design_system_changes) | the brand and two versions, else the two newest | yes |
| [`si.read.browse_view`](/reference/tools/si-read-browse_view) | a `BrowseViewInput` | yes |
| [`si.read.candidates`](/reference/tools/si-read-candidates) | Reads the candidates of one brand, narrowed by a buyer profile or by a place | yes |
| [`si.read.capture_health`](/reference/tools/si-read-capture_health) | a platform and a window, or nothing | yes |
| [`si.read.capture_rules`](/reference/tools/si-read-capture_rules) | a platform, or nothing | yes |
| [`si.read.catalogue`](/reference/tools/si-read-catalogue) | a tenant or a brand | yes |
| [`si.read.chain`](/reference/tools/si-read-chain) | a brand | yes |
| [`si.read.compare`](/reference/tools/si-read-compare) | two brands, a question from the closed list of comparisons | yes |
| [`si.read.connectors`](/reference/tools/si-read-connectors) | a tenant or a brand | yes |
| [`si.read.consent`](/reference/tools/si-read-consent) | the person or tenant, and the use | yes |
| [`si.read.coverage`](/reference/tools/si-read-coverage) | a cell, or a scope of entities with a window | yes |
| [`si.read.coverage_by_cell`](/reference/tools/si-read-coverage_by_cell) | a source, or a scope with a window | yes |
| [`si.read.document`](/reference/tools/si-read-document) | the document, the version, the caller | yes |
| [`si.read.document_changes`](/reference/tools/si-read-document_changes) | two versions | yes |
| [`si.read.effect`](/reference/tools/si-read-effect) | a move, the window | yes |
| [`si.read.entity`](/reference/tools/si-read-entity) | an entity, and the two dates | yes |
| [`si.read.estimate`](/reference/tools/si-read-estimate) | an estimator, the case | yes |
| [`si.read.explain_catch`](/reference/tools/si-read-explain_catch) | the match | yes |
| [`si.read.failed_calls`](/reference/tools/si-read-failed_calls) | a tenant | yes |
| [`si.read.fit_frame`](/reference/tools/si-read-fit_frame) | Reads the frame of one fit search | yes |
| [`si.read.fit_plays`](/reference/tools/si-read-fit_plays) | Reads the tactics that fit one phase of the search, for a vertical or a kind of offering | yes |
| [`si.read.forecasts`](/reference/tools/si-read-forecasts) | a play or a tactic, across brands | yes |
| [`si.read.grounding_priors`](/reference/tools/si-read-grounding_priors) | a platform, or nothing (`GroundingPriorsInput`) | yes |
| [`si.read.groundings`](/reference/tools/si-read-groundings) | one capture's, one entity's, or every grounding in a place | yes |
| [`si.read.instruction_set`](/reference/tools/si-read-instruction_set) | nothing | yes |
| [`si.read.intelligence`](/reference/tools/si-read-intelligence) | a subject and a kind of intelligence | yes |
| [`si.read.invitations`](/reference/tools/si-read-invitations) | nothing | yes |
| [`si.read.invoices`](/reference/tools/si-read-invoices) | a period, or nothing | yes |
| [`si.read.leads`](/reference/tools/si-read-leads) | Reads the leads of one brand, narrowed by a place, a condition or a user | yes |
| [`si.read.ledger`](/reference/tools/si-read-ledger) | a strategy, the window | yes |
| [`si.read.lineage`](/reference/tools/si-read-lineage) | an artefact | yes |
| [`si.read.lookup`](/reference/tools/si-read-lookup) | a key: a namespace with a value, or a name with a place, and with a name a breadth. And the two dates | yes |
| [`si.read.map`](/reference/tools/si-read-map) | a brand, and the two dates | yes |
| [`si.read.market`](/reference/tools/si-read-market) | a brand, a segment, the window | yes |
| [`si.read.market_twin`](/reference/tools/si-read-market_twin) | Reads one market twin, and the date to read it as of | yes |
| [`si.read.methods`](/reference/tools/si-read-methods) | a question, or nothing | yes |
| [`si.read.model_families`](/reference/tools/si-read-model_families) | Reads the model families that fit a vertical or a representation | yes |
| [`si.read.monitor_strength`](/reference/tools/si-read-monitor_strength) | the monitor and a window | yes |
| [`si.read.page_changes`](/reference/tools/si-read-page_changes) | a `PageChangesInput` | yes |
| [`si.read.parameter`](/reference/tools/si-read-parameter) | its name | yes |
| [`si.read.plan_report`](/reference/tools/si-read-plan_report) | a strategy and a window (`PlanReportInput`) | yes |
| [`si.read.policy_replay`](/reference/tools/si-read-policy_replay) | a policy row and its version, a strategy and a window (`PolicyReplayInput`) | yes |
| [`si.read.posture`](/reference/tools/si-read-posture) | a community, the window | yes |
| [`si.read.predicate_language`](/reference/tools/si-read-predicate_language) | the register's name | yes |
| [`si.read.propensity`](/reference/tools/si-read-propensity) | a lead, a move or a play, and which faces, actors or content or both (`PropensityInput`) | yes |
| [`si.read.proxy`](/reference/tools/si-read-proxy) | the proxy and its version, the two dates, and a place | yes |
| [`si.read.receipts`](/reference/tools/si-read-receipts) | the kind, export or erasure | yes |
| [`si.read.register`](/reference/tools/si-read-register) | its name, and a version or *current* | yes |
| [`si.read.registered`](/reference/tools/si-read-registered) | a register and a name | yes |
| [`si.read.roles`](/reference/tools/si-read-roles) | nothing, or one role | yes |
| [`si.read.scrape_runs`](/reference/tools/si-read-scrape_runs) | a `ScrapeRunsInput` | yes |
| [`si.read.signals`](/reference/tools/si-read-signals) | a monitor, a subject, a kind or a strategy, and a window | yes |
| [`si.read.simulation_frame`](/reference/tools/si-read-simulation_frame) | Reads the frame of one simulation | yes |
| [`si.read.source_procedure`](/reference/tools/si-read-source_procedure) | a source | yes |
| [`si.read.speed_to_lead`](/reference/tools/si-read-speed_to_lead) | Reads the delay from delivery to the first touch for one brand, over a window | yes |
| [`si.read.strategy`](/reference/tools/si-read-strategy) | a strategy, as of a date (`StrategyReadInput`) | yes |
| [`si.read.systems_models`](/reference/tools/si-read-systems_models) | Reads the systems models that fit one vertical or one kind of offering | yes |
| [`si.read.trajectory`](/reference/tools/si-read-trajectory) | a strategy or one move, and a window (`TrajectoryInput`) | yes |
| [`si.read.under_test`](/reference/tools/si-read-under_test) | a subject or a scope, and the two dates | yes |
| [`si.read.unit`](/reference/tools/si-read-unit) | the kind, the id, the caller | yes |
| [`si.read.usage_statement`](/reference/tools/si-read-usage_statement) | a period | yes |
| [`si.read.value_chain`](/reference/tools/si-read-value_chain) | Reads the value chain of one vertical, with the brand whose participants are placed on it | yes |
| [`si.read.vertical`](/reference/tools/si-read-vertical) | the vertical, or a brand whose vertical is meant | yes |
| [`si.read.why`](/reference/tools/si-read-why) | any unit | yes |
| [`si.read.withheld`](/reference/tools/si-read-withheld) | Reads the withheld count for one brand or one tenant | yes |
| [`si.view.capabilities`](/reference/tools/si-view-capabilities) | nothing | yes |
| [`si.view.journey`](/reference/tools/si-view-journey) | a unit's id | yes |
| [`si.view.oldest`](/reference/tools/si-view-oldest) | a kind, a place, and how many | yes |
| [`si.view.pairings`](/reference/tools/si-view-pairings) | a scope | yes |
| [`si.view.stocks`](/reference/tools/si-view-stocks) | a part, a kind or a place, and a scope the caller holds | yes |
| [`si.view.usage`](/reference/tools/si-view-usage) | a tenant, a kind, a provider, a window | yes |
| [`si.view.waiting`](/reference/tools/si-view-waiting) | the caller | yes |
| [`si.act.act_through_connector`](/reference/tools/si-act-act_through_connector) | the installed connector, the kind, the arguments with their sources | no |
| [`si.act.annotate`](/reference/tools/si-act-annotate) | an `Annotation` with the target *an entity* and the entity's id, from the web shell, the desktop shell, the agent or the API; in the side panel the same type travels inside the page's reading | no |
| [`si.act.arm_monitor`](/reference/tools/si-act-arm_monitor) | the monitor's version, and for arming the preview it was judged by | no |
| [`si.act.arm_play`](/reference/tools/si-act-arm_play) | a strategy, the play and its version, the goal it serves, and the share it is armed on with its holdout (a share under one makes the play an experiment) | no |
| [`si.act.assign`](/reference/tools/si-act-assign) | Assigns one lead to one user by hand, or hands it on | no |
| [`si.act.beat`](/reference/tools/si-act-beat) | what runs, and when | no |
| [`si.act.bind_buyer`](/reference/tools/si-act-bind_buyer) | the kind, an offering or a segment, the weight, the mode | no |
| [`si.act.board`](/reference/tools/si-act-board) | the board with its tiles | no |
| [`si.act.browse_step`](/reference/tools/si-act-browse_step) | a `BrowseStepInput` | no |
| [`si.act.build_document`](/reference/tools/si-act-build_document) | the document, the two dates, which default to now | no |
| [`si.act.capacity`](/reference/tools/si-act-capacity) | Sets how many new leads one user can take in a period | no |
| [`si.act.capture`](/reference/tools/si-act-capture) | the document, the network events, the address, the person's identity | no |
| [`si.act.capture_rule`](/reference/tools/si-act-capture_rule) | the rule | no |
| [`si.act.change_plan`](/reference/tools/si-act-change_plan) | the plan kind | no |
| [`si.act.correct`](/reference/tools/si-act-correct) | the id of the wrong event, and the right facts | no |
| [`si.act.crawl`](/reference/tools/si-act-crawl) | a `ScrapeRequest` whose scope names the site's seeds, with sitemap-driven discovery on | no |
| [`si.act.decide_ask`](/reference/tools/si-act-decide_ask) | the ask, by a user who may | no |
| [`si.act.decide_brand_design`](/reference/tools/si-act-decide_brand_design) | the brand, the value's path, the decision (accepted, declined, changed) and, when changed, the tenant's own value, with the reason | no |
| [`si.act.decide_move`](/reference/tools/si-act-decide_move) | the move, the caller | no |
| [`si.act.deepen`](/reference/tools/si-act-deepen) | an observation, and the depth: fetched in full, or given meaning | no |
| [`si.act.dry_run`](/reference/tools/si-act-dry_run) | an action | no |
| [`si.act.erase_person`](/reference/tools/si-act-erase_person) | the person | no |
| [`si.act.export_tenant`](/reference/tools/si-act-export_tenant) | nothing | no |
| [`si.act.goal`](/reference/tools/si-act-goal) | a strategy, a measure, a target, a window | no |
| [`si.act.grant`](/reference/tools/si-act-grant) | the grant, by a caller who may give it | no |
| [`si.act.ground`](/reference/tools/si-act-ground) | exactly one of a capture, an entity, a text or an address, and a breadth (`GroundInput`) | no |
| [`si.act.hold_identity`](/reference/tools/si-act-hold_identity) | the platform, the scopes the rows declare | no |
| [`si.act.install_connector`](/reference/tools/si-act-install_connector) | the connector, the ways chosen, and the identity for each | no |
| [`si.act.install_pack`](/reference/tools/si-act-install_pack) | a brand, the pack and its version | no |
| [`si.act.invite`](/reference/tools/si-act-invite) | an address and a role | no |
| [`si.act.keep_basket`](/reference/tools/si-act-keep_basket) | its name, its scope and its proxies by version | no |
| [`si.act.keep_buyer`](/reference/tools/si-act-keep_buyer) | the whole profile as it should stand next, with its predicate's tree given in full, its bindings and its ladder | no |
| [`si.act.keep_ladder`](/reference/tools/si-act-keep_ladder) | its ordered rungs, each a predicate over the population, and the rung that qualifies; the rungs' predicates in full where they are not yet kept | no |
| [`si.act.keep_monitor`](/reference/tools/si-act-keep_monitor) | its name, its predicate, the place it runs at, the kind of signal it makes, the strategy where one is chosen, and for a platform monitor the vertical | no |
| [`si.act.keep_play`](/reference/tools/si-act-keep_play) | a play for a brand, written once by the platform as an original or by the tenant: its goal, its condition as a predicate over its population, its class, its tactic, the move it proposes, its measure, its window, its forecast rule, its comparison, when it stops, and its graph of moves as edges (`KeepPlayInput`); the predicates given in full are kept by their hashes in the same call | no |
| [`si.act.keep_proxy`](/reference/tools/si-act-keep_proxy) | a proxy: its name, the facet kind it stands for, its scope, its rule as a predicate, its strength, its named control, its failure mode, and whether it is aggregate-only | no |
| [`si.act.make_brand_design_system`](/reference/tools/si-act-make_brand_design_system) | the brand, and the site when it is not the brand row's own | no |
| [`si.act.make_market_twin`](/reference/tools/si-act-make_market_twin) | Makes one market twin from a vertical, a segment, a brand, a template and the way of going to market it serves | no |
| [`si.act.map_brand`](/reference/tools/si-act-map_brand) | a web address, and the brand scope to hold the map | no |
| [`si.act.mark_lead`](/reference/tools/si-act-mark_lead) | Marks a condition on one lead, with a reason where the condition asks for one | no |
| [`si.act.mark_rival`](/reference/tools/si-act-mark_rival) | a brand, the rival's entity, the evidence | no |
| [`si.act.membership`](/reference/tools/si-act-membership) | the person's address, and the roles with where each is held | no |
| [`si.act.move_strategy`](/reference/tools/si-act-move_strategy) | a strategy, the place to move it to and the reason (`StrategyMoveInput`): drafted, simulated, rolled out in part, running, paused, ended | no |
| [`si.act.notification_channel`](/reference/tools/si-act-notification_channel) | Writes one notification channel, which is where a notice goes | no |
| [`si.act.notification_rule`](/reference/tools/si-act-notification_rule) | Writes one notification rule, which says who is told and never what happens | no |
| [`si.act.parameter`](/reference/tools/si-act-parameter) | a parameter by its name, its value and its scope | no |
| [`si.act.place_participant`](/reference/tools/si-act-place_participant) | Places one party in one role on one stock of a vertical's chain, with the evidence for it | no |
| [`si.act.probe_identity`](/reference/tools/si-act-probe_identity) | the identity | no |
| [`si.act.propose_move`](/reference/tools/si-act-propose_move) | a match of a play | no |
| [`si.act.publish`](/reference/tools/si-act-publish) | the version, the address, the visibility | no |
| [`si.act.raise_need`](/reference/tools/si-act-raise_need) | a cell's key, the reason and the value | no |
| [`si.act.record_fit_reading`](/reference/tools/si-act-record_fit_reading) | Records one result of a person's own test: the tactic, the market, the measure, its value, the sample and where it came from | no |
| [`si.act.remember`](/reference/tools/si-act-remember) | a memory and its scope | no |
| [`si.act.routing`](/reference/tools/si-act-routing) | Writes, previews or arms a routing rule from a predicate and the people or the team it attaches | no |
| [`si.act.run_action`](/reference/tools/si-act-run_action) | an action prepared by a move | no |
| [`si.act.scrape_template`](/reference/tools/si-act-scrape_template) | a `TemplateInput` | no |
| [`si.act.seed_tenant`](/reference/tools/si-act-seed_tenant) | the manifest and the window | no |
| [`si.act.set_aside_run`](/reference/tools/si-act-set_aside_run) | a `SetAsideRunInput`: the run's key and a person's plain reason | no |
| [`si.act.settle`](/reference/tools/si-act-settle) | a hypothesis, the standing, the caller | no |
| [`si.act.settle_match`](/reference/tools/si-act-settle_match) | the possible match, and a user's answer or a proof | no |
| [`si.act.sign_up`](/reference/tools/si-act-sign_up) | the company's name, and its domain where known, from a signed-in person who belongs to no tenant | no |
| [`si.act.strategy`](/reference/tools/si-act-strategy) | a brand or brands, a name, a window if any | no |
| [`si.act.sync_rule`](/reference/tools/si-act-sync_rule) | the installed connector, the offer, the fields of section 2.8 | no |
| [`si.act.undo`](/reference/tools/si-act-undo) | a done action | no |
| [`si.act.undo_action`](/reference/tools/si-act-undo_action) | the move | no |
| [`si.act.undo_merge`](/reference/tools/si-act-undo_merge) | the merge or the decision, and the reason | no |
| [`si.act.watch`](/reference/tools/si-act-watch) | a public entity | no |
| [`si.act.watch_site`](/reference/tools/si-act-watch_site) | a `WatchSiteInput` | no |
| [`si.act.webhook`](/reference/tools/si-act-webhook) | the address, what to be told about, and a secret to sign with | no |
| [`si.act.weigh`](/reference/tools/si-act-weigh) | a hypothesis, and a fact or a test's reading | no |
| [`si.act.withdraw`](/reference/tools/si-act-withdraw) | a publishing | no |
| [`si.act.workflow`](/reference/tools/si-act-workflow) | its steps and what starts it | no |
| [`si.work.backfill`](/reference/tools/si-work-backfill) | a source, an access method, a window, a plane | no |
| [`si.work.browse_open`](/reference/tools/si-work-browse_open) | a `BrowseOpenInput` | no |
| [`si.work.browse_take_over`](/reference/tools/si-work-browse_take_over) | a `BrowseTakeOverInput` | no |
| [`si.work.build_facet`](/reference/tools/si-work-build_facet) | a facet kind, a seed (a predicate, a list of communities, or a place from the gazetteer), the scope, and the positive and negative controls | no |
| [`si.work.cancel`](/reference/tools/si-work-cancel) | the preview | no |
| [`si.work.download_set`](/reference/tools/si-work-download_set) | a `DownloadInput` | no |
| [`si.work.download_set_control`](/reference/tools/si-work-download_set_control) | a `DownloadControlInput` | no |
| [`si.work.lay_strategy`](/reference/tools/si-work-lay_strategy) | Lays one strategy on one twin, with the bounds of the run | no |
| [`si.work.mine`](/reference/tools/si-work-mine) | the caller | no |
| [`si.work.run_procedure`](/reference/tools/si-work-run_procedure) | the procedure and its inputs | no |
| [`si.work.search_fit`](/reference/tools/si-work-search_fit) | Searches for product-market fit from one end: an offering looking for its markets, or a concept looking for a market | no |
| [`si.work.simulate_market`](/reference/tools/si-work-simulate_market) | Runs one systems model template over a market, with the interventions to try and the bounds of the run | no |
| [`si.work.status`](/reference/tools/si-work-status) | the task | no |
| [`si.work.local_procedure`](/reference/tools/si-work-local_procedure) | a named procedure whose inputs are files in the workspace | no |
| [`si.harness.delegate`](/reference/tools/si-harness-delegate) | words, in a strategy | no |
| [`si.files.download`](/reference/tools/si-files-download) | a file's pointer from a task or a document, and where in the workspace to put it | no |
| [`si.files.upload`](/reference/tools/si-files-upload) | a path inside the workspace, and what the file is for | no |
| [`si.files.list`](/reference/tools/si-files-list) | a path inside the workspace, or nothing | no |
| [`si.files.workspace`](/reference/tools/si-files-workspace) | nothing, or a folder to make the workspace | no |
| [`si.economics.benchmarks`](/reference/tools/si-economics-benchmarks) | a driver, and a population or a buyer profile | no |
| [`si.economics.estimate`](/reference/tools/si-economics-estimate) | `EstimateReturnInput`: the buyer (an entity, a lead, a buyer profile or a session), the offering or tier, the stated numbers, and whether to simulate | no |
| [`si.economics.ladder`](/reference/tools/si-economics-ladder) | nothing, or a version | no |
| [`si.economics.models`](/reference/tools/si-economics-models) | a vertical, a segment or a buyer profile | no |
| [`si.economics.offer`](/reference/tools/si-economics-offer) | `ReadingOfferedInput`: the buyer profile, the model, the drivers to ask | no |
| [`si.economics.study`](/reference/tools/si-economics-study) | `PricingStudyInput`: the methods to run, the buyer profiles, the rivals' window | no |



## Resources


| resource | what it serves |
|---|---|
| `ui://scale-intelligence/cards/{kind}` | the apps extension's bundle that draws one kind of card, one per body type of the tool register |
| `si://register/{name}` | the rows of one register with their hash |
| `si://unit/{kind}/{id}` | one unit by its kind and id, as of two dates |
| `si://monitor/{id}` | an armed monitor; its firing reaches a connected agent as an update of this resource |



## Prompts


| prompt | what it does |
|---|---|
| `stage-0-proves-itself` | the named procedure that proves the core: eight steps, each with the planted fault that must show red first |
| `run-procedure` | any named procedure of the register, by name, with its inputs |



## Host connection
Claude Code and any other MCP host can start the stdio shim, which forwards each message to the local server's socket. A host can also connect to the platform's MCP server over HTTPS with a key. The page on [connecting an agent](/install/connecting-an-agent) describes both connections.


---
title: "session: sign out"
description: "the session or the user to nothing"
section: reference
address: /reference/session/sign_out
contract: 0476e35e6e275db5
---

# session: sign out

the session or the user to nothing

[figure: The caller sends SignOutInput to /v1/session/sign_out. The platform returns a card whose body is Nothing.]

<span class="op-method">POST</span><span class="op-path">/v1/session/sign_out</span>

End a session, or every session of a user. The call needs the user rung under a token with the read grant, and it is served by either, by the size bound.

The route takes [SignOutInput](/concepts/signoutinput) and returns a card whose body is [Nothing](/concepts/nothing).



## Request body
The request body is [SignOutInput](/concepts/signoutinput).



| field | type | required | note |
|---|---|---|---|
| `session` | `id` | no |  |
| `user` | `id` | no |  |



## Response
The route returns a card whose body is [Nothing](/concepts/nothing). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the user rung and a token with the read grant. The platform or the desktop app serves this route.

## Example
The example sends the smallest body that SignOutInput allows. The build validates it against the schema of SignOutInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/session/sign_out \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{}'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.session.sign_out({});
// answer.body is a Nothing. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/session/sign_out",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={}).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/session/sign_out")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&SignOutInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.session.sign_out` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Nothing`. The [tool's page](/reference/tools/si-session-sign_out) describes it.


---
title: "session: whoami"
description: "a token, a key, or a run's identity to the caller, with its scopes and its access scopes"
section: reference
address: /reference/session/whoami
contract: 0476e35e6e275db5
---

# session: whoami

a token, a key, or a run's identity to the caller, with its scopes and its access scopes

[figure: The caller sends WhoAmIInput to /v1/session/whoami. The platform returns a card whose body is Caller.]

<span class="op-method">POST</span><span class="op-path">/v1/session/whoami</span>

Who is calling, which is the API gateway's work. The call needs the user rung under a token with the read grant, and it is served by the platform.

The route takes [WhoAmIInput](/concepts/whoamiinput) and returns a card whose body is [Caller](/concepts/caller).



## Request body
The request body is [WhoAmIInput](/concepts/whoamiinput).



| field | type | required | note |
|---|---|---|---|
| `token` | `text` | no | never logged |
| `key` | `id` | no |  |
| `run` | `id` | no |  |



## Response
The route returns a card whose body is [Caller](/concepts/caller). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the user rung and a token with the read grant. The platform serves this route.

## Example
The example sends the smallest body that WhoAmIInput allows. The build validates it against the schema of WhoAmIInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/session/whoami \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{}'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.session.whoami({});
// answer.body is a Caller. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/session/whoami",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={}).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/session/whoami")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&WhoAmIInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.session.whoami` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Caller`. The [tool's page](/reference/tools/si-session-whoami) describes it.


---
title: "session: sign in"
description: "nothing, or the tenant to sign in to to the way the browser was opened, then the caller as a view once the code came back; the refresh token goes to the keychain and never to the caller"
section: reference
address: /reference/session/sign_in
contract: 0476e35e6e275db5
---

# session: sign in

nothing, or the tenant to sign in to to the way the browser was opened, then the caller as a view once the code came back; the refresh token goes to the keychain and never to the caller

[figure: The caller sends SignInInput to /v1/session/sign_in. The platform returns a card whose body is Caller.]

<span class="op-method">POST</span><span class="op-path">/v1/session/sign_in</span>

From the local server's own. The call needs the user rung under a token with the read grant, and it is served by the installed app.

The route takes [SignInInput](/concepts/signininput) and returns a card whose body is [Caller](/concepts/caller).



## Request body
The request body is [SignInInput](/concepts/signininput).



| field | type | required | note |
|---|---|---|---|
| `tenant` | `id` | no |  |
| `token` | `text` | no | an access token the identity provider issued, checked six ways at the face; never logged |



## Response
The route returns a card whose body is [Caller](/concepts/caller). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the user rung and a token with the read grant. The desktop app serves this route.

## Example
The example sends the smallest body that SignInInput allows. The build validates it against the schema of SignInInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/session/sign_in \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{}'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.session.sign_in({});
// answer.body is a Caller. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/session/sign_in",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={}).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/session/sign_in")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&SignInInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.session.sign_in` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Caller`. The [tool's page](/reference/tools/si-session-sign_in) describes it.


---
title: "session: cache"
description: "nothing, or a call to forget to what the app holds from earlier answers, by call and date, and when each expires"
section: reference
address: /reference/session/cache
contract: 0476e35e6e275db5
---

# session: cache

nothing, or a call to forget to what the app holds from earlier answers, by call and date, and when each expires

[figure: The caller sends CacheInput to /v1/session/cache. The platform returns a card whose body is CacheView.]

<span class="op-method">POST</span><span class="op-path">/v1/session/cache</span>

From the local server's own. The call needs the user rung under a token with the read grant, and it is served by the installed app.

The route takes [CacheInput](/concepts/cacheinput) and returns a card whose body is [CacheView](/concepts/cacheview).



## Request body
The request body is [CacheInput](/concepts/cacheinput).



| field | type | required | note |
|---|---|---|---|
| `forget` | `text` | no | the call name and its input hash |



## Response
The route returns a card whose body is [CacheView](/concepts/cacheview). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the user rung and a token with the read grant. The desktop app serves this route.

## Example
The example sends the smallest body that CacheInput allows. The build validates it against the schema of CacheInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/session/cache \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{}'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.session.cache({});
// answer.body is a CacheView. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/session/cache",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={}).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/session/cache")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&CacheInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.session.cache` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/CacheView`. The [tool's page](/reference/tools/si-session-cache) describes it.


---
title: "ask: facts"
description: "a unit or a population, the date it was true, and the date we knew it, as two parameters."
section: reference
address: /reference/ask/facts
contract: 0476e35e6e275db5
---

# ask: facts

a unit or a population, the date it was true, and the date we knew it, as two parameters.

[figure: The caller sends FactsInput to /v1/ask/facts. The platform returns a card whose body is FactsAnswer.]

<span class="op-method">POST</span><span class="op-path">/v1/ask/facts</span>

Read facts as of. The call needs the strategy rung under a token with the ask grant, and it is served by either, by the size bound.

The route takes [FactsInput](/concepts/factsinput) and returns a card whose body is [FactsAnswer](/concepts/factsanswer).



## Request body
The request body is [FactsInput](/concepts/factsinput).



| field | type | required | note |
|---|---|---|---|
| `unit` | [UnitRef](/concepts/unitref) | no |  |
| `population` | [Predicate](/concepts/predicate) | no |  |
| `attributes` | `[text]` | no |  |



## Response
The route returns a card whose body is [FactsAnswer](/concepts/factsanswer). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the strategy rung and a token with the ask grant. The platform or the desktop app serves this route.

## Example
The example sends the smallest body that FactsInput allows. The build validates it against the schema of FactsInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/ask/facts \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{}'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.ask.facts({});
// answer.body is a FactsAnswer. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/ask/facts",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={}).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/ask/facts")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&FactsInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.ask.facts` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/FactsAnswer`. The [tool's page](/reference/tools/si-ask-facts) describes it.


---
title: "ask: get content"
description: "a `ContentRequest` to a `ContentResponse`, the page in bronze"
section: reference
address: /reference/ask/get_content
contract: 0476e35e6e275db5
---

# ask: get content

a `ContentRequest` to a `ContentResponse`, the page in bronze

[figure: The caller sends ContentRequest to /v1/ask/get_content. The platform returns a card whose body is ContentResponse.]

<span class="op-method">POST</span><span class="op-path">/v1/ask/get_content</span><span class="op-note">a task, 202</span>

Get content. The call needs the strategy rung under a token with the ask grant, and it is served by either, by the size bound.

The route takes [ContentRequest](/concepts/contentrequest) and returns a card whose body is [ContentResponse](/concepts/contentresponse).



## Request body
The request body is [ContentRequest](/concepts/contentrequest).



| field | type | required | note |
|---|---|---|---|
| `address` | `text` | yes |  |
| `returns` | `[one of article \| html \| markdown \| text \| links \| metadata \| stylesheets \| scripts \| images \| screenshot \| pdf \| network events]` | yes | article is the main content with its title, author, published time and language, as CrawlKit's extractor returns it |
| `filter` | [ResourceFilter](/concepts/resourcefilter) | yes |  |
| `as_identity` | `id` | no | a held identity, lent by a grant: its cookie jar, session token, access token or API key |
| `proxy_policy` | [ProxyPolicy](/concepts/proxypolicy) | no |  |
| `wait_for` | `text` | no | a selector or a time |
| `cache_for` | `duration` | no |  |
| `credit_cells` | `[id]` | no |  |



## Response
The route returns a card whose body is [ContentResponse](/concepts/contentresponse). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true. This route runs as a long step and returns a task with status 202. `POST /v1/work/status` returns the task's progress, and `POST /v1/work/cancel` stops the task.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the strategy rung and a token with the ask grant. The platform or the desktop app serves this route.

## Example
The example sends the smallest body that ContentRequest allows. The build validates it against the schema of ContentRequest.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/ask/get_content \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "address": "…", "returns": [], "filter": { "allow_types": [], "deny_types": [], "allow_patterns": [], "deny_patterns": [], "render": "static" } }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.ask.get_content({
    "address": "…",
    "returns": [],
    "filter": {
      "allow_types": [],
      "deny_types": [],
      "allow_patterns": [],
      "deny_patterns": [],
      "render": "static"
    }
  });
// answer.body is a ContentResponse. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/ask/get_content",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "address": "…",
      "returns": [],
      "filter": {
        "allow_types": [],
        "deny_types": [],
        "allow_patterns": [],
        "deny_patterns": [],
        "render": "static"
      }
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/ask/get_content")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&ContentRequest { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.ask.get_content` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/ContentResponse`. The [tool's page](/reference/tools/si-ask-get_content) describes it.


---
title: "ask: groups"
description: "a scope, the two dates, and the resolution of the cut to the cluster response cards: each group with the share each layer of likeness contributed, its top communities, words and domains, its size and trend by month, and the proxies that placed its members"
section: reference
address: /reference/ask/groups
contract: 0476e35e6e275db5
---

# ask: groups

a scope, the two dates, and the resolution of the cut to the cluster response cards: each group with the share each layer of likeness contributed, its top communities, words and domains, its size and trend by month, and the proxies that placed its members

[figure: The caller sends GroupsInput to /v1/ask/groups. The platform returns a card whose body is [ClusterCard].]

<span class="op-method">POST</span><span class="op-path">/v1/ask/groups</span>

Read the groups. The call needs the strategy rung under a token with the ask grant, and it is served by either, by the size bound.

The route takes [GroupsInput](/concepts/groupsinput) and returns a card whose body is [ClusterCard](/concepts/clustercard).



## Request body
The request body is [GroupsInput](/concepts/groupsinput).



| field | type | required | note |
|---|---|---|---|
| `scope` | [Predicate](/concepts/predicate) | yes |  |
| `resolution` | `share` | yes |  |



## Response
The route returns a card whose body is [ClusterCard](/concepts/clustercard). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the strategy rung and a token with the ask grant. The platform or the desktop app serves this route.

## Example
The example sends the smallest body that GroupsInput allows. The build validates it against the schema of GroupsInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/ask/groups \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "scope": { "tree": { "form": "group" }, "population": "…", "tree_hash": "…", "register_hash": "…", "compiler_version": "…", "comparator_versions": {} }, "resolution": 0 }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.ask.groups({
    "scope": {
      "tree": {
        "form": "group"
      },
      "population": "…",
      "tree_hash": "…",
      "register_hash": "…",
      "compiler_version": "…",
      "comparator_versions": {}
    },
    "resolution": 0
  });
// answer.body is a [ClusterCard]. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/ask/groups",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "scope": {
        "tree": {
          "form": "group"
        },
        "population": "…",
        "tree_hash": "…",
        "register_hash": "…",
        "compiler_version": "…",
        "comparator_versions": {}
      },
      "resolution": 0
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/ask/groups")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&GroupsInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.ask.groups` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/ClusterCard`. The [tool's page](/reference/tools/si-ask-groups) describes it.


---
title: "ask: judge fit"
description: "Judges one entity against a buyer profile, and against a brand whose offerings' fit is in question to The answer gives the fit with each criterion and its highlights, the temperature with its reason, and the verdict."
section: reference
address: /reference/ask/judge_fit
contract: 0476e35e6e275db5
---

# ask: judge fit

Judges one entity against a buyer profile, and against a brand whose offerings' fit is in question to The answer gives the fit with each criterion and its highlights, the temperature with its reason, and the verdict.

[figure: The caller sends JudgeFitInput to /v1/ask/judge_fit. The platform returns a card whose body is BuyerFitVerdict.]

<span class="op-method">POST</span><span class="op-path">/v1/ask/judge_fit</span>

Judge a fit. The call needs the strategy rung under a token with the ask grant, and it is served by the platform.

The route takes [JudgeFitInput](/concepts/judgefitinput) and returns a card whose body is [BuyerFitVerdict](/concepts/buyerfitverdict).



## Request body
The request body is [JudgeFitInput](/concepts/judgefitinput).



| field | type | required | note |
|---|---|---|---|
| `kind_of_buyer` | `id` | yes |  |
| `entity` | `id` | yes |  |
| `brand` | `id` | no |  |



## Response
The route returns a card whose body is [BuyerFitVerdict](/concepts/buyerfitverdict). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the strategy rung and a token with the ask grant. The platform serves this route.

## Example
The example sends the smallest body that JudgeFitInput allows. The build validates it against the schema of JudgeFitInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/ask/judge_fit \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "kind_of_buyer": "…", "entity": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.ask.judge_fit({
    "kind_of_buyer": "…",
    "entity": "…"
  });
// answer.body is a BuyerFitVerdict. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/ask/judge_fit",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "kind_of_buyer": "…",
      "entity": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/ask/judge_fit")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&JudgeFitInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.ask.judge_fit` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/BuyerFitVerdict`. The [tool's page](/reference/tools/si-ask-judge_fit) describes it.


---
title: "ask: keep question"
description: "the question and its scope to a saved question"
section: reference
address: /reference/ask/keep_question
contract: 0476e35e6e275db5
---

# ask: keep question

the question and its scope to a saved question

[figure: The caller sends KeepQuestionInput to /v1/ask/keep_question. The platform returns a card whose body is SavedQuestion.]

<span class="op-method">POST</span><span class="op-path">/v1/ask/keep_question</span>

Keep a question. The call needs the user rung under a token with the ask grant, and it is served by either, by the size bound.

The route takes [KeepQuestionInput](/concepts/keepquestioninput) and returns a card whose body is [SavedQuestion](/concepts/savedquestion).



## Request body
The request body is [KeepQuestionInput](/concepts/keepquestioninput).



| field | type | required | note |
|---|---|---|---|
| `question` | [SavedQuestion](/concepts/savedquestion) | yes |  |



## Response
The route returns a card whose body is [SavedQuestion](/concepts/savedquestion). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the user rung and a token with the ask grant. The platform or the desktop app serves this route.

## Example
The example sends the smallest body that KeepQuestionInput allows. The build validates it against the schema of KeepQuestionInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/ask/keep_question \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "question": { "name": "…", "over": "stocks", "query": null, "scope": { "level": "shared" } } }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.ask.keep_question({
    "question": {
      "name": "…",
      "over": "stocks",
      "query": null,
      "scope": {
        "level": "shared"
      }
    }
  });
// answer.body is a SavedQuestion. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/ask/keep_question",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "question": {
        "name": "…",
        "over": "stocks",
        "query": null,
        "scope": {
          "level": "shared"
        }
      }
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/ask/keep_question")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&KeepQuestionInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.ask.keep_question` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/SavedQuestion`. The [tool's page](/reference/tools/si-ask-keep_question) describes it.


---
title: "ask: neighbours"
description: "an entity, one kind of connection, and the two dates to the members, one hop away, and whether the cap was reached"
section: reference
address: /reference/ask/neighbours
contract: 0476e35e6e275db5
---

# ask: neighbours

an entity, one kind of connection, and the two dates to the members, one hop away, and whether the cap was reached

[figure: The caller sends NeighboursInput to /v1/ask/neighbours. The platform returns a card whose body is NeighboursAnswer.]

<span class="op-method">POST</span><span class="op-path">/v1/ask/neighbours</span>

Neighbours. The call needs the strategy rung under a token with the ask grant, and it is served by either, by the size bound.

The route takes [NeighboursInput](/concepts/neighboursinput) and returns a card whose body is [NeighboursAnswer](/concepts/neighboursanswer).



## Request body
The request body is [NeighboursInput](/concepts/neighboursinput).



| field | type | required | note |
|---|---|---|---|
| `entity` | `id` | yes |  |
| `kind` | [KindOfConnection](/concepts/kindofconnection) | yes |  |
| `role` | `text` | no |  |



## Response
The route returns a card whose body is [NeighboursAnswer](/concepts/neighboursanswer). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the strategy rung and a token with the ask grant. The platform or the desktop app serves this route.

## Example
The example sends the smallest body that NeighboursInput allows. The build validates it against the schema of NeighboursInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/ask/neighbours \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "entity": "…", "kind": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.ask.neighbours({
    "entity": "…",
    "kind": "…"
  });
// answer.body is a NeighboursAnswer. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/ask/neighbours",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "entity": "…",
      "kind": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/ask/neighbours")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&NeighboursInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.ask.neighbours` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/NeighboursAnswer`. The [tool's page](/reference/tools/si-ask-neighbours) describes it.


---
title: "ask: preview"
description: "a predicate or its hash, the place, the window, the speeds wanted, and the caller with the surface it calls from to the typed answer of section 2.3, as it fills"
section: reference
address: /reference/ask/preview
contract: 0476e35e6e275db5
---

# ask: preview

a predicate or its hash, the place, the window, the speeds wanted, and the caller with the surface it calls from to the typed answer of section 2.3, as it fills

[figure: The caller sends PreviewInput to /v1/ask/preview. The platform returns a card whose body is PreviewAnswer.]

<span class="op-method">POST</span><span class="op-path">/v1/ask/preview</span><span class="op-note">a task, 202</span>

Preview. The call needs the strategy rung under a token with the ask grant, and it is served by either, by the size bound.

The route takes [PreviewInput](/concepts/previewinput) and returns a card whose body is [PreviewAnswer](/concepts/previewanswer).



## Request body
The request body is [PreviewInput](/concepts/previewinput).



| field | type | required | note |
|---|---|---|---|
| `predicate` | [Predicate](/concepts/predicate) | no |  |
| `predicate_hash` | `hash` | no |  |
| `place` | [PlaceARunsAt](/concepts/placearunsat) | yes |  |
| `window` | [Window](/concepts/window) | yes |  |
| `speeds` | `[one of instant \| the last seven days \| the whole record]` | yes |  |



## Response
The route returns a card whose body is [PreviewAnswer](/concepts/previewanswer). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true. This route runs as a long step and returns a task with status 202. `POST /v1/work/status` returns the task's progress, and `POST /v1/work/cancel` stops the task.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the strategy rung and a token with the ask grant. The platform or the desktop app serves this route.

## Example
The example sends the smallest body that PreviewInput allows. The build validates it against the schema of PreviewInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/ask/preview \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "place": "…", "window": { "from": "…", "to": "…" }, "speeds": [] }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.ask.preview({
    "place": "…",
    "window": {
      "from": "…",
      "to": "…"
    },
    "speeds": []
  });
// answer.body is a PreviewAnswer. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/ask/preview",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "place": "…",
      "window": {
        "from": "…",
        "to": "…"
      },
      "speeds": []
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/ask/preview")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&PreviewInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.ask.preview` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/PreviewAnswer`. The [tool's page](/reference/tools/si-ask-preview) describes it.


---
title: "ask: propose template"
description: "a `ProposeTemplateInput` to a draft template with fields and evidence spans for the person to confirm"
section: reference
address: /reference/ask/propose_template
contract: 0476e35e6e275db5
---

# ask: propose template

a `ProposeTemplateInput` to a draft template with fields and evidence spans for the person to confirm

[figure: The caller sends ProposeTemplateInput to /v1/ask/propose_template. The platform returns a card whose body is ExtractionTemplate.]

<span class="op-method">POST</span><span class="op-path">/v1/ask/propose_template</span><span class="op-note">a task, 202</span>

Propose a scrape template from a sample page. The call needs the strategy rung under a token with the ask grant, and it is served by either, by the size bound.

The route takes [ProposeTemplateInput](/concepts/proposetemplateinput) and returns a card whose body is [ExtractionTemplate](/concepts/extractiontemplate).



## Request body
The request body is [ProposeTemplateInput](/concepts/proposetemplateinput).



| field | type | required | note |
|---|---|---|---|
| `address` | `text` | yes |  |
| `page_kind` | `one of listing \| detail \| feed \| table \| search results \| infinite scroll \| document \| API response` | yes |  |
| `marked` | `[text]` | yes | the values the person pointed at |
| `as_identity` | `id` | no |  |



## Response
The route returns a card whose body is [ExtractionTemplate](/concepts/extractiontemplate). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true. This route runs as a long step and returns a task with status 202. `POST /v1/work/status` returns the task's progress, and `POST /v1/work/cancel` stops the task.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the strategy rung and a token with the ask grant. The platform or the desktop app serves this route.

## Example
The example sends the smallest body that ProposeTemplateInput allows. The build validates it against the schema of ProposeTemplateInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/ask/propose_template \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "address": "…", "page_kind": "listing", "marked": [] }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.ask.propose_template({
    "address": "…",
    "page_kind": "listing",
    "marked": []
  });
// answer.body is a ExtractionTemplate. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/ask/propose_template",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "address": "…",
      "page_kind": "listing",
      "marked": []
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/ask/propose_template")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&ProposeTemplateInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.ask.propose_template` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/ExtractionTemplate`. The [tool's page](/reference/tools/si-ask-propose_template) describes it.


---
title: "ask: read source"
description: "the installed connector, the kind, a cursor to a page of source objects, the next cursor, the cells credited"
section: reference
address: /reference/ask/read_source
contract: 0476e35e6e275db5
---

# ask: read source

the installed connector, the kind, a cursor to a page of source objects, the next cursor, the cells credited

[figure: The caller sends ReadSourceInput to /v1/ask/read_source. The platform returns a card whose body is ReadSourcePage.]

<span class="op-method">POST</span><span class="op-path">/v1/ask/read_source</span><span class="op-note">a task, 202</span>

Run a kind of reading. The call needs the strategy rung under a token with the ask grant, and it is served by either, by the size bound.

The route takes [ReadSourceInput](/concepts/readsourceinput) and returns a card whose body is [ReadSourcePage](/concepts/readsourcepage).



## Request body
The request body is [ReadSourceInput](/concepts/readsourceinput).



| field | type | required | note |
|---|---|---|---|
| `installed_connector` | `id` | yes |  |
| `kind_of_reading` | `id` | yes |  |
| `cursor` | `text` | no |  |
| `credit_cells` | `[id]` | no |  |



## Response
The route returns a card whose body is [ReadSourcePage](/concepts/readsourcepage). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true. This route runs as a long step and returns a task with status 202. `POST /v1/work/status` returns the task's progress, and `POST /v1/work/cancel` stops the task.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the strategy rung and a token with the ask grant. The platform or the desktop app serves this route.

## Example
The example sends the smallest body that ReadSourceInput allows. The build validates it against the schema of ReadSourceInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/ask/read_source \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "installed_connector": "…", "kind_of_reading": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.ask.read_source({
    "installed_connector": "…",
    "kind_of_reading": "…"
  });
// answer.body is a ReadSourcePage. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/ask/read_source",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "installed_connector": "…",
      "kind_of_reading": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/ask/read_source")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&ReadSourceInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.ask.read_source` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/ReadSourcePage`. The [tool's page](/reference/tools/si-ask-read_source) describes it.


---
title: "ask: saved view"
description: "the view. Or the view and a caller to the definition. Or its rows, with when they were built"
section: reference
address: /reference/ask/saved_view
contract: 0476e35e6e275db5
---

# ask: saved view

the view. Or the view and a caller to the definition. Or its rows, with when they were built

[figure: The caller sends SavedViewInput to /v1/ask/saved_view. The platform returns a card whose body is SavedViewAnswer.]

<span class="op-method">POST</span><span class="op-path">/v1/ask/saved_view</span>

Keep, read a saved view. The call needs the strategy rung under a token with the ask grant, and it is served by either, by the size bound.

The route takes [SavedViewInput](/concepts/savedviewinput) and returns a card whose body is [SavedViewAnswer](/concepts/savedviewanswer).



## Request body
The request body is [SavedViewInput](/concepts/savedviewinput).



| field | type | required | note |
|---|---|---|---|
| `view` | [SavedView](/concepts/savedview) | no | to keep |
| `read` | `id` | no | to read its rows |
| `page` | `count` | no |  |



## Response
The route returns a card whose body is [SavedViewAnswer](/concepts/savedviewanswer). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the strategy rung and a token with the ask grant. The platform or the desktop app serves this route.

## Example
The example sends the smallest body that SavedViewInput allows. The build validates it against the schema of SavedViewInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/ask/saved_view \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{}'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.ask.saved_view({});
// answer.body is a SavedViewAnswer. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/ask/saved_view",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={}).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/ask/saved_view")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&SavedViewInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.ask.saved_view` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/SavedViewAnswer`. The [tool's page](/reference/tools/si-ask-saved_view) describes it.


---
title: "ask: scrape"
description: "a `ScrapeRequest` to a `ScrapeResult`, the rows as source objects with their evidence spans"
section: reference
address: /reference/ask/scrape
contract: 0476e35e6e275db5
---

# ask: scrape

a `ScrapeRequest` to a `ScrapeResult`, the rows as source objects with their evidence spans

[figure: The caller sends ScrapeRequest to /v1/ask/scrape. The platform returns a card whose body is ScrapeResult.]

<span class="op-method">POST</span><span class="op-path">/v1/ask/scrape</span><span class="op-note">a task, 202</span>

Scrape. The call needs the strategy rung under a token with the ask grant, and it is served by either, by the size bound.

The route takes [ScrapeRequest](/concepts/scraperequest) and returns a card whose body is [ScrapeResult](/concepts/scraperesult).



## Request body
The request body is [ScrapeRequest](/concepts/scraperequest).



| field | type | required | note |
|---|---|---|---|
| `template` | `id` | no | an extraction template; any of its parts may be overridden below |
| `scope` | [CrawlScope](/concepts/crawlscope) | no | required when no template |
| `fields` | [FieldSpec](/concepts/fieldspec) | no | declared selectors |
| `schema` | `json` | no | for the model-assisted reader, every value with its evidence span or refused |
| `source_object` | [SourceObject](/concepts/sourceobject) | yes | declared inline for one scrape, or a registered row |
| `mapping` | [Mapping](/concepts/mapping) | no |  |
| `filter` | [ResourceFilter](/concepts/resourcefilter) | yes |  |
| `as_identity` | `id` | no |  |
| `proxy_policy` | [ProxyPolicy](/concepts/proxypolicy) | no |  |
| `credit_cells` | `[id]` | no |  |
| `asked_by` | `text` | no | who asked for the run, as the caller's kind, or the crawler for an address a walk found; the beat takes what a person or the agent asked before the crawler's own discoveries, oldest first within each |



## Response
The route returns a card whose body is [ScrapeResult](/concepts/scraperesult). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true. This route runs as a long step and returns a task with status 202. `POST /v1/work/status` returns the task's progress, and `POST /v1/work/cancel` stops the task.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the strategy rung and a token with the ask grant. The platform or the desktop app serves this route.

## Example
The example sends the smallest body that ScrapeRequest allows. The build validates it against the schema of ScrapeRequest.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/ask/scrape \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "source_object": "…", "filter": { "allow_types": [], "deny_types": [], "allow_patterns": [], "deny_patterns": [], "render": "static" } }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.ask.scrape({
    "source_object": "…",
    "filter": {
      "allow_types": [],
      "deny_types": [],
      "allow_patterns": [],
      "deny_patterns": [],
      "render": "static"
    }
  });
// answer.body is a ScrapeResult. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/ask/scrape",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "source_object": "…",
      "filter": {
        "allow_types": [],
        "deny_types": [],
        "allow_patterns": [],
        "deny_patterns": [],
        "render": "static"
      }
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/ask/scrape")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&ScrapeRequest { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.ask.scrape` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/ScrapeResult`. The [tool's page](/reference/tools/si-ask-scrape) describes it.


---
title: "ask: search"
description: "a `SearchRequest` to `SearchResult` rows, streamed as engines answer, credited to cells"
section: reference
address: /reference/ask/search
contract: 0476e35e6e275db5
---

# ask: search

a `SearchRequest` to `SearchResult` rows, streamed as engines answer, credited to cells

[figure: The caller sends SearchRequest to /v1/ask/search. The platform returns a card whose body is [SearchResult].]

<span class="op-method">POST</span><span class="op-path">/v1/ask/search</span><span class="op-note">a task, 202</span>

Search. The call needs the strategy rung under a token with the ask grant, and it is served by either, by the size bound.

The route takes [SearchRequest](/concepts/searchrequest) and returns a card whose body is [SearchResult](/concepts/searchresult).



## Request body
The request body is [SearchRequest](/concepts/searchrequest).



| field | type | required | note |
|---|---|---|---|
| `query` | `text` | yes |  |
| `engines` | `[text]` | no | empty means the rows' default set |
| `categories` | `[text]` | no | general, news, science, social, code, images, videos, files, maps |
| `time_range` | [Window](/concepts/window) | no |  |
| `language` | `text` | no |  |
| `safe_search` | `one of off \| moderate \| strict` | yes |  |
| `count` | `count` | yes |  |
| `page` | `count` | yes |  |
| `as_identity` | `id` | no | a held identity, lent by a grant |
| `credit_cells` | `[id]` | no |  |



## Response
The route returns a card whose body is [SearchResult](/concepts/searchresult). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true. This route runs as a long step and returns a task with status 202. `POST /v1/work/status` returns the task's progress, and `POST /v1/work/cancel` stops the task.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the strategy rung and a token with the ask grant. The platform or the desktop app serves this route.

## Example
The example sends the smallest body that SearchRequest allows. The build validates it against the schema of SearchRequest.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/ask/search \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "query": "…", "safe_search": "off", "count": 0, "page": 0 }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.ask.search({
    "query": "…",
    "safe_search": "off",
    "count": 0,
    "page": 0
  });
// answer.body is a [SearchResult]. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/ask/search",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "query": "…",
      "safe_search": "off",
      "count": 0,
      "page": 0
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/ask/search")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&SearchRequest { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.ask.search` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/SearchResult`. The [tool's page](/reference/tools/si-ask-search) describes it.


---
title: "ask: semantic search"
description: "a text or a subject's vector, the model, a floor and a population to the units above the floor."
section: reference
address: /reference/ask/semantic_search
contract: 0476e35e6e275db5
---

# ask: semantic search

a text or a subject's vector, the model, a floor and a population to the units above the floor.

[figure: The caller sends SemanticSearchInput to /v1/ask/semantic_search. The platform returns a card whose body is SemanticSearchAnswer.]

<span class="op-method">POST</span><span class="op-path">/v1/ask/semantic_search</span>

Semantic search. The call needs the strategy rung under a token with the ask grant, and it is served by the platform.

The route takes [SemanticSearchInput](/concepts/semanticsearchinput) and returns a card whose body is [SemanticSearchAnswer](/concepts/semanticsearchanswer).



## Request body
The request body is [SemanticSearchInput](/concepts/semanticsearchinput).



| field | type | required | note |
|---|---|---|---|
| `text` | `text` | no |  |
| `subject` | [UnitRef](/concepts/unitref) | no |  |
| `model` | [Model](/concepts/model) | yes |  |
| `floor` | `share` | yes |  |
| `population` | [Predicate](/concepts/predicate) | yes |  |



## Response
The route returns a card whose body is [SemanticSearchAnswer](/concepts/semanticsearchanswer). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the strategy rung and a token with the ask grant. The platform serves this route.

## Example
The example sends the smallest body that SemanticSearchInput allows. The build validates it against the schema of SemanticSearchInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/ask/semantic_search \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "model": "…", "floor": 0, "population": { "tree": { "form": "group" }, "population": "…", "tree_hash": "…", "register_hash": "…", "compiler_version": "…", "comparator_versions": {} } }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.ask.semantic_search({
    "model": "…",
    "floor": 0,
    "population": {
      "tree": {
        "form": "group"
      },
      "population": "…",
      "tree_hash": "…",
      "register_hash": "…",
      "compiler_version": "…",
      "comparator_versions": {}
    }
  });
// answer.body is a SemanticSearchAnswer. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/ask/semantic_search",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "model": "…",
      "floor": 0,
      "population": {
        "tree": {
          "form": "group"
        },
        "population": "…",
        "tree_hash": "…",
        "register_hash": "…",
        "compiler_version": "…",
        "comparator_versions": {}
      }
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/ask/semantic_search")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&SemanticSearchInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.ask.semantic_search` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/SemanticSearchAnswer`. The [tool's page](/reference/tools/si-ask-semantic_search) describes it.


---
title: "ask: sql"
description: "a query, in a strategy to rows, with how many and whether a bound was reached"
section: reference
address: /reference/ask/sql
contract: 0476e35e6e275db5
---

# ask: sql

a query, in a strategy to rows, with how many and whether a bound was reached

[figure: The caller sends SqlInput to /v1/ask/sql. The platform returns a card whose body is SqlAnswer.]

<span class="op-method">POST</span><span class="op-path">/v1/ask/sql</span>

Ask the workbench. The call needs the strategy rung under a token with the ask grant, and it is served by either, by the size bound.

The route takes [SqlInput](/concepts/sqlinput) and returns a card whose body is [SqlAnswer](/concepts/sqlanswer).



## Request body
The request body is [SqlInput](/concepts/sqlinput).



| field | type | required | note |
|---|---|---|---|
| `query` | `text` | yes |  |
| `strategy` | `id` | yes |  |
| `bound` | `count` | no |  |



## Response
The route returns a card whose body is [SqlAnswer](/concepts/sqlanswer). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the strategy rung and a token with the ask grant. The platform or the desktop app serves this route.

## Example
The example sends the smallest body that SqlInput allows. The build validates it against the schema of SqlInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/ask/sql \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "query": "…", "strategy": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.ask.sql({
    "query": "…",
    "strategy": "…"
  });
// answer.body is a SqlAnswer. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/ask/sql",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "query": "…",
      "strategy": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/ask/sql")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&SqlInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.ask.sql` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/SqlAnswer`. The [tool's page](/reference/tools/si-ask-sql) describes it.


---
title: "ask: local"
description: "a question in one of the ask tools' owning types, over the files the app may read to the card, answered by the app's own engine over its tenant's files, with the same foot"
section: reference
address: /reference/ask/local
contract: 0476e35e6e275db5
---

# ask: local

a question in one of the ask tools' owning types, over the files the app may read to the card, answered by the app's own engine over its tenant's files, with the same foot

[figure: The caller sends LocalInput to /v1/ask/local. The platform returns a card whose body is Card.]

<span class="op-method">POST</span><span class="op-path">/v1/ask/local</span>

From the local server's own. The call needs the strategy rung under a token with the ask grant, and it is served by the installed app.

The route takes [LocalInput](/concepts/localinput) and returns a card whose body is [Card](/concepts/card).



## Request body
The request body is [LocalInput](/concepts/localinput).



| field | type | required | note |
|---|---|---|---|
| `tool` | `text` | yes | an ask tool |
| `input` | `json` | yes | the serialisation of that tool's input |



## Response
The route returns a card whose body is [Card](/concepts/card). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the strategy rung and a token with the ask grant. The desktop app serves this route.

## Example
The example sends the smallest body that LocalInput allows. The build validates it against the schema of LocalInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/ask/local \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "tool": "…", "input": null }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.ask.local({
    "tool": "…",
    "input": null
  });
// answer.body is a Card. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/ask/local",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "tool": "…",
      "input": null
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/ask/local")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&LocalInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.ask.local` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Card`. The [tool's page](/reference/tools/si-ask-local) describes it.


---
title: "read: attributes"
description: "a population and, where wanted, a window to the attributes its units carry, each with its plain name, the units that carry it, the value type read and up to three examples, most carried first, with the units read and in, and the partial answer when the budget ran out"
section: reference
address: /reference/read/attributes
contract: 0476e35e6e275db5
---

# read: attributes

a population and, where wanted, a window to the attributes its units carry, each with its plain name, the units that carry it, the value type read and up to three examples, most carried first, with the units read and in, and the partial answer when the budget ran out

[figure: The caller sends AttributesInput to /v1/read/attributes. The platform returns a card whose body is PopulationAttributes.]

<span class="op-method">POST</span><span class="op-path">/v1/read/attributes</span>

The attributes of a population. The call needs the strategy rung under a token with the read grant, and it is served by the platform.

The route takes [AttributesInput](/concepts/attributesinput) and returns a card whose body is [PopulationAttributes](/concepts/populationattributes).



## Request body
The request body is [AttributesInput](/concepts/attributesinput).



| field | type | required | note |
|---|---|---|---|
| `population` | [Population](/concepts/population) | yes |  |
| `window` | [Window](/concepts/window) | no | the units read; the whole record when absent |



## Response
The route returns a card whose body is [PopulationAttributes](/concepts/populationattributes). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the strategy rung and a token with the read grant. The platform serves this route.

## Example
The example sends the smallest body that AttributesInput allows. The build validates it against the schema of AttributesInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/read/attributes \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "population": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.read.attributes({
    "population": "…"
  });
// answer.body is a PopulationAttributes. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/read/attributes",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "population": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/read/attributes")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&AttributesInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.read.attributes` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/PopulationAttributes`. The [tool's page](/reference/tools/si-read-attributes) describes it.


---
title: "read: audience map"
description: "a brand, two facets or a facet and a community, the window to the shared subjects, the share, the lift, the negative control that bounds it, and the size as bounds"
section: reference
address: /reference/read/audience_map
contract: 0476e35e6e275db5
---

# read: audience map

a brand, two facets or a facet and a community, the window to the shared subjects, the share, the lift, the negative control that bounds it, and the size as bounds

[figure: The caller sends AudienceMapInput to /v1/read/audience_map. The platform returns a card whose body is AudienceMapCell.]

<span class="op-method">POST</span><span class="op-path">/v1/read/audience_map</span>

Read the audience map. The call needs the brand rung under a token with the read grant, and it is served by either, by the size bound.

The route takes [AudienceMapInput](/concepts/audiencemapinput) and returns a card whose body is [AudienceMapCell](/concepts/audiencemapcell).



## Request body
The request body is [AudienceMapInput](/concepts/audiencemapinput).



| field | type | required | note |
|---|---|---|---|
| `brand` | `id` | yes |  |
| `first` | `id` | yes |  |
| `second` | `id` | yes |  |
| `window` | [Window](/concepts/window) | yes |  |
| `adult` | `bool` | no | when true, the rooms marked adult count in the crossing; left out by default |



## Response
The route returns a card whose body is [AudienceMapCell](/concepts/audiencemapcell). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the brand rung and a token with the read grant. The platform or the desktop app serves this route.

## Example
The example sends the smallest body that AudienceMapInput allows. The build validates it against the schema of AudienceMapInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/read/audience_map \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "brand": "…", "first": "…", "second": "…", "window": { "from": "…", "to": "…" } }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.read.audience_map({
    "brand": "…",
    "first": "…",
    "second": "…",
    "window": {
      "from": "…",
      "to": "…"
    }
  });
// answer.body is a AudienceMapCell. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/read/audience_map",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "brand": "…",
      "first": "…",
      "second": "…",
      "window": {
        "from": "…",
        "to": "…"
      }
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/read/audience_map")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&AudienceMapInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.read.audience_map` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/AudienceMapCell`. The [tool's page](/reference/tools/si-read-audience_map) describes it.


---
title: "read: basket"
description: "the basket, and one subject, a set of subjects, a scope predicate or a cut into groups, with the window to the basket reading as a fact: memberships with their scale of association and likelihood for one subject; population readings and co-membership for a set; proxy against group with lift and control for groups"
section: reference
address: /reference/read/basket
contract: 0476e35e6e275db5
---

# read: basket

the basket, and one subject, a set of subjects, a scope predicate or a cut into groups, with the window to the basket reading as a fact: memberships with their scale of association and likelihood for one subject; population readings and co-membership for a set; proxy against group with lift and control for groups

[figure: The caller sends BasketReadInput to /v1/read/basket. The platform returns a card whose body is BasketReading.]

<span class="op-method">POST</span><span class="op-path">/v1/read/basket</span>

Read a basket. The call needs the strategy rung under a token with the read grant, and it is served by either, by the size bound.

The route takes [BasketReadInput](/concepts/basketreadinput) and returns a card whose body is [BasketReading](/concepts/basketreading).



## Request body
The request body is [BasketReadInput](/concepts/basketreadinput).



| field | type | required | note |
|---|---|---|---|
| `basket` | `id` | yes |  |
| `subject` | `id` | no | one subject |
| `subjects` | `[id]` | no | a set, under the size bound |
| `scope` | [Predicate](/concepts/predicate) | no | a population by predicate |
| `resolution` | `share` | no | a cut into groups at this resolution |
| `window` | [Window](/concepts/window) | no |  |



## Response
The route returns a card whose body is [BasketReading](/concepts/basketreading). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the strategy rung and a token with the read grant. The platform or the desktop app serves this route.

## Example
The example sends the smallest body that BasketReadInput allows. The build validates it against the schema of BasketReadInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/read/basket \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "basket": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.read.basket({
    "basket": "…"
  });
// answer.body is a BasketReading. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/read/basket",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "basket": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/read/basket")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&BasketReadInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.read.basket` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/BasketReading`. The [tool's page](/reference/tools/si-read-basket) describes it.


---
title: "read: board"
description: "the board and a period to the board with every tile's numbers, each with its basis and its population"
section: reference
address: /reference/read/board
contract: 0476e35e6e275db5
---

# read: board

the board and a period to the board with every tile's numbers, each with its basis and its population

[figure: The caller sends BoardReadInput to /v1/read/board. The platform returns a card whose body is BoardAnswer.]

<span class="op-method">POST</span><span class="op-path">/v1/read/board</span>

Read a board. The call needs the tenant rung under a token with the read grant, and it is served by the platform.

The route takes [BoardReadInput](/concepts/boardreadinput) and returns a card whose body is [BoardAnswer](/concepts/boardanswer).



## Request body
The request body is [BoardReadInput](/concepts/boardreadinput).



| field | type | required | note |
|---|---|---|---|
| `board` | `id` | yes |  |
| `period` | [Window](/concepts/window) | no |  |



## Response
The route returns a card whose body is [BoardAnswer](/concepts/boardanswer). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the tenant rung and a token with the read grant. The platform serves this route.

## Example
The example sends the smallest body that BoardReadInput allows. The build validates it against the schema of BoardReadInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/read/board \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "board": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.read.board({
    "board": "…"
  });
// answer.body is a BoardAnswer. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/read/board",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "board": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/read/board")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&BoardReadInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.read.board` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/BoardAnswer`. The [tool's page](/reference/tools/si-read-board) describes it.


---
title: "read: brand design system"
description: "the brand, and a version, else the newest to the design system as it stands, with every basis"
section: reference
address: /reference/read/brand_design_system
contract: 0476e35e6e275db5
---

# read: brand design system

the brand, and a version, else the newest to the design system as it stands, with every basis

[figure: The caller sends BrandDesignSystemInput to /v1/read/brand_design_system. The platform returns a card whose body is BrandDesignSystem.]

<span class="op-method">POST</span><span class="op-path">/v1/read/brand_design_system</span>

Read a brand's design system. The call needs the brand rung under a token with the read grant, and it is served by either, by the size bound.

The route takes [BrandDesignSystemInput](/concepts/branddesignsysteminput) and returns a card whose body is [BrandDesignSystem](/concepts/branddesignsystem).



## Request body
The request body is [BrandDesignSystemInput](/concepts/branddesignsysteminput).



| field | type | required | note |
|---|---|---|---|
| `brand` | `id` | yes |  |
| `version` | `count` | no |  |



## Response
The route returns a card whose body is [BrandDesignSystem](/concepts/branddesignsystem). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the brand rung and a token with the read grant. The platform or the desktop app serves this route.

## Example
The example sends the smallest body that BrandDesignSystemInput allows. The build validates it against the schema of BrandDesignSystemInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/read/brand_design_system \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "brand": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.read.brand_design_system({
    "brand": "…"
  });
// answer.body is a BrandDesignSystem. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/read/brand_design_system",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "brand": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/read/brand_design_system")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&BrandDesignSystemInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.read.brand_design_system` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/BrandDesignSystem`. The [tool's page](/reference/tools/si-read-brand_design_system) describes it.


---
title: "read: brand design system changes"
description: "the brand and two versions, else the two newest to every value that differs, by path, with the basis on each side, and the counts"
section: reference
address: /reference/read/brand_design_system_changes
contract: 0476e35e6e275db5
---

# read: brand design system changes

the brand and two versions, else the two newest to every value that differs, by path, with the basis on each side, and the counts

[figure: The caller sends BrandDesignSystemChangesInput to /v1/read/brand_design_system_changes. The platform returns a card whose body is BrandDesignSystemDiff.]

<span class="op-method">POST</span><span class="op-path">/v1/read/brand_design_system_changes</span>

What changed in a brand's design system. The call needs the brand rung under a token with the read grant, and it is served by either, by the size bound.

The route takes [BrandDesignSystemChangesInput](/concepts/branddesignsystemchangesinput) and returns a card whose body is [BrandDesignSystemDiff](/concepts/branddesignsystemdiff).



## Request body
The request body is [BrandDesignSystemChangesInput](/concepts/branddesignsystemchangesinput).



| field | type | required | note |
|---|---|---|---|
| `brand` | `id` | yes |  |
| `from_version` | `count` | no |  |
| `to_version` | `count` | no |  |



## Response
The route returns a card whose body is [BrandDesignSystemDiff](/concepts/branddesignsystemdiff). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the brand rung and a token with the read grant. The platform or the desktop app serves this route.

## Example
The example sends the smallest body that BrandDesignSystemChangesInput allows. The build validates it against the schema of BrandDesignSystemChangesInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/read/brand_design_system_changes \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "brand": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.read.brand_design_system_changes({
    "brand": "…"
  });
// answer.body is a BrandDesignSystemDiff. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/read/brand_design_system_changes",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "brand": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/read/brand_design_system_changes")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&BrandDesignSystemChangesInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.read.brand_design_system_changes` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/BrandDesignSystemDiff`. The [tool's page](/reference/tools/si-read-brand_design_system_changes) describes it.


---
title: "read: browse view"
description: "a `BrowseViewInput` to one frame of the page as the person sees it, with its size and address, for a dashboard that shows the session live and forwards the person's clicks and words as steps"
section: reference
address: /reference/read/browse_view
contract: 0476e35e6e275db5
---

# read: browse view

a `BrowseViewInput` to one frame of the page as the person sees it, with its size and address, for a dashboard that shows the session live and forwards the person's clicks and words as steps

[figure: The caller sends BrowseViewInput to /v1/read/browse_view. The platform returns a card whose body is BrowseView.]

<span class="op-method">POST</span><span class="op-path">/v1/read/browse_view</span>

Read a browsing session's view. The call needs the strategy rung under a token with the read grant, and it is served by either, by the size bound.

The route takes [BrowseViewInput](/concepts/browseviewinput) and returns a card whose body is [BrowseView](/concepts/browseview).



## Request body
The request body is [BrowseViewInput](/concepts/browseviewinput).



| field | type | required | note |
|---|---|---|---|
| `session` | `id` | yes |  |



## Response
The route returns a card whose body is [BrowseView](/concepts/browseview). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the strategy rung and a token with the read grant. The platform or the desktop app serves this route.

## Example
The example sends the smallest body that BrowseViewInput allows. The build validates it against the schema of BrowseViewInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/read/browse_view \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "session": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.read.browse_view({
    "session": "…"
  });
// answer.body is a BrowseView. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/read/browse_view",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "session": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/read/browse_view")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&BrowseViewInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.read.browse_view` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/BrowseView`. The [tool's page](/reference/tools/si-read-browse_view) describes it.


---
title: "read: candidates"
description: "Reads the candidates of one brand, narrowed by a buyer profile or by a place to Each candidate arrives with the signals gathered about it, the rung it has reached, and what it still lacks to qualify"
section: reference
address: /reference/read/candidates
contract: 0476e35e6e275db5
---

# read: candidates

Reads the candidates of one brand, narrowed by a buyer profile or by a place to Each candidate arrives with the signals gathered about it, the rung it has reached, and what it still lacks to qualify

[figure: The caller sends CandidatesInput to /v1/read/candidates. The platform returns a card whose body is [Candidate].]

<span class="op-method">POST</span><span class="op-path">/v1/read/candidates</span>

Candidates. One candidate. The call needs the strategy rung under a token with the read grant, and it is served by the platform.

The route takes [CandidatesInput](/concepts/candidatesinput) and returns a card whose body is [Candidate](/concepts/candidate).



## Request body
The request body is [CandidatesInput](/concepts/candidatesinput).



| field | type | required | note |
|---|---|---|---|
| `brand` | `id` | yes |  |
| `kind_of_buyer` | `id` | no |  |
| `place` | `text` | no |  |
| `candidate` | `id` | no | one candidate |



## Response
The route returns a card whose body is [Candidate](/concepts/candidate). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the strategy rung and a token with the read grant. The platform serves this route.

## Example
The example sends the smallest body that CandidatesInput allows. The build validates it against the schema of CandidatesInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/read/candidates \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "brand": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.read.candidates({
    "brand": "…"
  });
// answer.body is a [Candidate]. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/read/candidates",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "brand": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/read/candidates")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&CandidatesInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.read.candidates` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Candidate`. The [tool's page](/reference/tools/si-read-candidates) describes it.


---
title: "read: capture health"
description: "a platform and a window, or nothing to captures by platform in the window against the window before, with a verdict"
section: reference
address: /reference/read/capture_health
contract: 0476e35e6e275db5
---

# read: capture health

a platform and a window, or nothing to captures by platform in the window against the window before, with a verdict

[figure: The caller sends CaptureHealthInput to /v1/read/capture_health. The platform returns a card whose body is CaptureHealth.]

<span class="op-method">POST</span><span class="op-path">/v1/read/capture_health</span>

Read the health of capture. The call needs the user rung under a token with the read grant, and it is served by the platform.

The route takes [CaptureHealthInput](/concepts/capturehealthinput) and returns a card whose body is [CaptureHealth](/concepts/capturehealth).



## Request body
The request body is [CaptureHealthInput](/concepts/capturehealthinput).



| field | type | required | note |
|---|---|---|---|
| `platform` | `text` | no |  |
| `window` | [Window](/concepts/window) | no |  |



## Response
The route returns a card whose body is [CaptureHealth](/concepts/capturehealth). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the user rung and a token with the read grant. The platform serves this route.

## Example
The example sends the smallest body that CaptureHealthInput allows. The build validates it against the schema of CaptureHealthInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/read/capture_health \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{}'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.read.capture_health({});
// answer.body is a CaptureHealth. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/read/capture_health",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={}).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/read/capture_health")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&CaptureHealthInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.read.capture_health` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/CaptureHealth`. The [tool's page](/reference/tools/si-read-capture_health) describes it.


---
title: "read: capture rules"
description: "a platform, or nothing to the rules with each platform's readiness"
section: reference
address: /reference/read/capture_rules
contract: 0476e35e6e275db5
---

# read: capture rules

a platform, or nothing to the rules with each platform's readiness

[figure: The caller sends CaptureRulesInput to /v1/read/capture_rules. The platform returns a card whose body is [CaptureRule].]

<span class="op-method">POST</span><span class="op-path">/v1/read/capture_rules</span>

Read my capture rules. The call needs the user rung under a token with the read grant, and it is served by the platform.

The route takes [CaptureRulesInput](/concepts/capturerulesinput) and returns a card whose body is [CaptureRule](/concepts/capturerule).



## Request body
The request body is [CaptureRulesInput](/concepts/capturerulesinput).



| field | type | required | note |
|---|---|---|---|
| `platform` | `text` | no |  |



## Response
The route returns a card whose body is [CaptureRule](/concepts/capturerule). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the user rung and a token with the read grant. The platform serves this route.

## Example
The example sends the smallest body that CaptureRulesInput allows. The build validates it against the schema of CaptureRulesInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/read/capture_rules \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{}'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.read.capture_rules({});
// answer.body is a [CaptureRule]. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/read/capture_rules",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={}).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/read/capture_rules")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&CaptureRulesInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.read.capture_rules` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/CaptureRule`. The [tool's page](/reference/tools/si-read-capture_rules) describes it.


---
title: "read: catalogue"
description: "a tenant or a brand to every source and connector with its kinds of reading and action, its state, the identity it needs, its cost, its rights, its coverage and its health"
section: reference
address: /reference/read/catalogue
contract: 0476e35e6e275db5
---

# read: catalogue

a tenant or a brand to every source and connector with its kinds of reading and action, its state, the identity it needs, its cost, its rights, its coverage and its health

[figure: The caller sends CatalogueInput to /v1/read/catalogue. The platform returns a card whose body is [SourceCatalogueEntry].]

<span class="op-method">POST</span><span class="op-path">/v1/read/catalogue</span>

Read the catalogue. The call needs the tenant rung under a token with the read grant, and it is served by the platform.

The route takes [CatalogueInput](/concepts/catalogueinput) and returns a card whose body is [SourceCatalogueEntry](/concepts/sourcecatalogueentry).



## Request body
The request body is [CatalogueInput](/concepts/catalogueinput).



| field | type | required | note |
|---|---|---|---|
| `tenant` | `id` | no |  |
| `brand` | `id` | no |  |
| `filter` | `text` | no |  |



## Response
The route returns a card whose body is [SourceCatalogueEntry](/concepts/sourcecatalogueentry). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the tenant rung and a token with the read grant. The platform serves this route.

## Example
The example sends the smallest body that CatalogueInput allows. The build validates it against the schema of CatalogueInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/read/catalogue \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{}'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.read.catalogue({});
// answer.body is a [SourceCatalogueEntry]. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/read/catalogue",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={}).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/read/catalogue")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&CatalogueInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.read.catalogue` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/SourceCatalogueEntry`. The [tool's page](/reference/tools/si-read-catalogue) describes it.


---
title: "read: chain"
description: "a brand to its roles, its handovers and each handover's count with its instrument"
section: reference
address: /reference/read/chain
contract: 0476e35e6e275db5
---

# read: chain

a brand to its roles, its handovers and each handover's count with its instrument

[figure: The caller sends MapInput to /v1/read/chain. The platform returns a card whose body is Chain.]

<span class="op-method">POST</span><span class="op-path">/v1/read/chain</span>

Read the chain. The call needs the brand rung under a token with the read grant, and it is served by the platform.

The route takes [MapInput](/concepts/mapinput) and returns a card whose body is [Chain](/concepts/chain).



## Request body
The request body is [MapInput](/concepts/mapinput).



| field | type | required | note |
|---|---|---|---|
| `brand` | `id` | yes |  |



## Response
The route returns a card whose body is [Chain](/concepts/chain). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the brand rung and a token with the read grant. The platform serves this route.

## Example
The example sends the smallest body that MapInput allows. The build validates it against the schema of MapInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/read/chain \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "brand": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.read.chain({
    "brand": "…"
  });
// answer.body is a Chain. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/read/chain",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "brand": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/read/chain")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&MapInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.read.chain` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Chain`. The [tool's page](/reference/tools/si-read-chain) describes it.


---
title: "read: compare"
description: "two brands, a question from the closed list of comparisons to two summaries over one structure, each with its coverage"
section: reference
address: /reference/read/compare
contract: 0476e35e6e275db5
---

# read: compare

two brands, a question from the closed list of comparisons to two summaries over one structure, each with its coverage

[figure: The caller sends CompareInput to /v1/read/compare. The platform returns a card whose body is Comparison.]

<span class="op-method">POST</span><span class="op-path">/v1/read/compare</span>

Compare two brands. The call needs the brand rung under a token with the read grant, and it is served by the platform.

The route takes [CompareInput](/concepts/compareinput) and returns a card whose body is [Comparison](/concepts/comparison).



## Request body
The request body is [CompareInput](/concepts/compareinput).



| field | type | required | note |
|---|---|---|---|
| `first` | `id` | yes |  |
| `second` | `id` | yes |  |
| `question` | [ComparisonQuestion](/concepts/comparisonquestion) | yes |  |



## Response
The route returns a card whose body is [Comparison](/concepts/comparison). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the brand rung and a token with the read grant. The platform serves this route.

## Example
The example sends the smallest body that CompareInput allows. The build validates it against the schema of CompareInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/read/compare \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "first": "…", "second": "…", "question": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.read.compare({
    "first": "…",
    "second": "…",
    "question": "…"
  });
// answer.body is a Comparison. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/read/compare",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "first": "…",
      "second": "…",
      "question": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/read/compare")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&CompareInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.read.compare` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Comparison`. The [tool's page](/reference/tools/si-read-compare) describes it.


---
title: "read: connectors"
description: "a tenant or a brand to every kind of reading and of action, by source, with its state, the identity it needs, its cost and its rights"
section: reference
address: /reference/read/connectors
contract: 0476e35e6e275db5
---

# read: connectors

a tenant or a brand to every kind of reading and of action, by source, with its state, the identity it needs, its cost and its rights

[figure: The caller sends ConnectorsInput to /v1/read/connectors. The platform returns a card whose body is ConnectorOffer.]

<span class="op-method">POST</span><span class="op-path">/v1/read/connectors</span>

Read what can be installed. The call needs the tenant rung under a token with the read grant, and it is served by the platform.

The route takes [ConnectorsInput](/concepts/connectorsinput) and returns a card whose body is [ConnectorOffer](/concepts/connectoroffer).



## Request body
The request body is [ConnectorsInput](/concepts/connectorsinput).



| field | type | required | note |
|---|---|---|---|
| `tenant` | `id` | no |  |
| `brand` | `id` | no |  |



## Response
The route returns a card whose body is [ConnectorOffer](/concepts/connectoroffer). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the tenant rung and a token with the read grant. The platform serves this route.

## Example
The example sends the smallest body that ConnectorsInput allows. The build validates it against the schema of ConnectorsInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/read/connectors \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{}'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.read.connectors({});
// answer.body is a ConnectorOffer. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/read/connectors",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={}).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/read/connectors")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&ConnectorsInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.read.connectors` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/ConnectorOffer`. The [tool's page](/reference/tools/si-read-connectors) describes it.


---
title: "read: consent"
description: "the person or tenant, and the use to a fact."
section: reference
address: /reference/read/consent
contract: 0476e35e6e275db5
---

# read: consent

the person or tenant, and the use to a fact.

[figure: The caller sends ConsentInput to /v1/read/consent. The platform returns a card whose body is ConsentAnswer.]

<span class="op-method">POST</span><span class="op-path">/v1/read/consent</span>

Record or withdraw consent. Is there consent. The call needs the tenant rung under a token with the read grant, and it is served by the platform.

The route takes [ConsentInput](/concepts/consentinput) and returns a card whose body is [ConsentAnswer](/concepts/consentanswer).



## Request body
The request body is [ConsentInput](/concepts/consentinput).



| field | type | required | note |
|---|---|---|---|
| `subject` | `id` | yes |  |
| `use` | `text` | yes |  |
| `do` | `one of record \| withdraw \| ask` | yes |  |
| `how` | `text` | no |  |
| `evidence` | `[id]` | no |  |



## Response
The route returns a card whose body is [ConsentAnswer](/concepts/consentanswer). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the tenant rung and a token with the read grant. The platform serves this route.

## Example
The example sends the smallest body that ConsentInput allows. The build validates it against the schema of ConsentInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/read/consent \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "subject": "…", "use": "…", "do": "record" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.read.consent({
    "subject": "…",
    "use": "…",
    "do": "record"
  });
// answer.body is a ConsentAnswer. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/read/consent",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "subject": "…",
      "use": "…",
      "do": "record"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/read/consent")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&ConsentInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.read.consent` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/ConsentAnswer`. The [tool's page](/reference/tools/si-read-consent) describes it.


---
title: "read: coverage"
description: "a cell, or a scope of entities with a window to what has been read, when and how deep, in the three positions"
section: reference
address: /reference/read/coverage
contract: 0476e35e6e275db5
---

# read: coverage

a cell, or a scope of entities with a window to what has been read, when and how deep, in the three positions

[figure: The caller sends CoverageInput to /v1/read/coverage. The platform returns a card whose body is Coverage.]

<span class="op-method">POST</span><span class="op-path">/v1/read/coverage</span>

Read coverage. The call needs the brand rung under a token with the read grant, and it is served by the platform.

The route takes [CoverageInput](/concepts/coverageinput) and returns a card whose body is [Coverage](/concepts/coverage).



## Request body
The request body is [CoverageInput](/concepts/coverageinput).



| field | type | required | note |
|---|---|---|---|
| `cell` | `id` | no |  |
| `scope` | [Predicate](/concepts/predicate) | no |  |
| `window` | [Window](/concepts/window) | no |  |



## Response
The route returns a card whose body is [Coverage](/concepts/coverage). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the brand rung and a token with the read grant. The platform serves this route.

## Example
The example sends the smallest body that CoverageInput allows. The build validates it against the schema of CoverageInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/read/coverage \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{}'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.read.coverage({});
// answer.body is a Coverage. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/read/coverage",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={}).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/read/coverage")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&CoverageInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.read.coverage` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Coverage`. The [tool's page](/reference/tools/si-read-coverage) describes it.


---
title: "read: coverage by cell"
description: "a source, or a scope with a window to measured, never measured with the reason, withheld"
section: reference
address: /reference/read/coverage_by_cell
contract: 0476e35e6e275db5
---

# read: coverage by cell

a source, or a scope with a window to measured, never measured with the reason, withheld

[figure: The caller sends CoverageByCellInput to /v1/read/coverage_by_cell. The platform returns a card whose body is Coverage.]

<span class="op-method">POST</span><span class="op-path">/v1/read/coverage_by_cell</span>

Read coverage by cell. The call needs the brand rung under a token with the read grant, and it is served by either, by the size bound.

The route takes [CoverageByCellInput](/concepts/coveragebycellinput) and returns a card whose body is [Coverage](/concepts/coverage).



## Request body
The request body is [CoverageByCellInput](/concepts/coveragebycellinput).



| field | type | required | note |
|---|---|---|---|
| `source` | `id` | no |  |
| `scope` | [Predicate](/concepts/predicate) | no |  |
| `window` | [Window](/concepts/window) | no |  |



## Response
The route returns a card whose body is [Coverage](/concepts/coverage). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the brand rung and a token with the read grant. The platform or the desktop app serves this route.

## Example
The example sends the smallest body that CoverageByCellInput allows. The build validates it against the schema of CoverageByCellInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/read/coverage_by_cell \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{}'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.read.coverage_by_cell({});
// answer.body is a Coverage. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/read/coverage_by_cell",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={}).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/read/coverage_by_cell")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&CoverageByCellInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.read.coverage_by_cell` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Coverage`. The [tool's page](/reference/tools/si-read-coverage_by_cell) describes it.


---
title: "read: document"
description: "the document, the version, the caller to the version, with when it was built and what it was built from"
section: reference
address: /reference/read/document
contract: 0476e35e6e275db5
---

# read: document

the document, the version, the caller to the version, with when it was built and what it was built from

[figure: The caller sends DocumentInput to /v1/read/document. The platform returns a card whose body is Build.]

<span class="op-method">POST</span><span class="op-path">/v1/read/document</span>

Read a document. The call needs the brand rung under a token with the read grant, and it is served by either, by the size bound.

The route takes [DocumentInput](/concepts/documentinput) and returns a card whose body is [Build](/concepts/build).



## Request body
The request body is [DocumentInput](/concepts/documentinput).



| field | type | required | note |
|---|---|---|---|
| `document` | `id` | yes |  |
| `version` | `count` | no |  |



## Response
The route returns a card whose body is [Build](/concepts/build). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the brand rung and a token with the read grant. The platform or the desktop app serves this route.

## Example
The example sends the smallest body that DocumentInput allows. The build validates it against the schema of DocumentInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/read/document \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "document": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.read.document({
    "document": "…"
  });
// answer.body is a Build. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/read/document",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "document": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/read/document")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&DocumentInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.read.document` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Build`. The [tool's page](/reference/tools/si-read-document) describes it.


---
title: "read: document changes"
description: "two versions to every number that moved with its unit, every figure replaced"
section: reference
address: /reference/read/document_changes
contract: 0476e35e6e275db5
---

# read: document changes

two versions to every number that moved with its unit, every figure replaced

[figure: The caller sends DocumentChangesInput to /v1/read/document_changes. The platform returns a card whose body is WhatChanged.]

<span class="op-method">POST</span><span class="op-path">/v1/read/document_changes</span>

What changed. The call needs the brand rung under a token with the read grant, and it is served by the platform.

The route takes [DocumentChangesInput](/concepts/documentchangesinput) and returns a card whose body is [WhatChanged](/concepts/whatchanged).



## Request body
The request body is [DocumentChangesInput](/concepts/documentchangesinput).



| field | type | required | note |
|---|---|---|---|
| `document` | `id` | yes |  |
| `first` | `count` | yes |  |
| `second` | `count` | yes |  |



## Response
The route returns a card whose body is [WhatChanged](/concepts/whatchanged). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the brand rung and a token with the read grant. The platform serves this route.

## Example
The example sends the smallest body that DocumentChangesInput allows. The build validates it against the schema of DocumentChangesInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/read/document_changes \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "document": "…", "first": 0, "second": 0 }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.read.document_changes({
    "document": "…",
    "first": 0,
    "second": 0
  });
// answer.body is a WhatChanged. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/read/document_changes",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "document": "…",
      "first": 0,
      "second": 0
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/read/document_changes")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&DocumentChangesInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.read.document_changes` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/WhatChanged`. The [tool's page](/reference/tools/si-read-document_changes) describes it.


---
title: "read: effect"
description: "a move, the window to the effect with its interval, or withheld with what would settle it"
section: reference
address: /reference/read/effect
contract: 0476e35e6e275db5
---

# read: effect

a move, the window to the effect with its interval, or withheld with what would settle it

[figure: The caller sends EffectInput to /v1/read/effect. The platform returns a card whose body is Effect.]

<span class="op-method">POST</span><span class="op-path">/v1/read/effect</span>

Read the effect. The call needs the strategy rung under a token with the read grant, and it is served by the platform.

The route takes [EffectInput](/concepts/effectinput) and returns a card whose body is [Effect](/concepts/effect).



## Request body
The request body is [EffectInput](/concepts/effectinput).



| field | type | required | note |
|---|---|---|---|
| `move` | `id` | yes |  |
| `window` | [Window](/concepts/window) | no |  |



## Response
The route returns a card whose body is [Effect](/concepts/effect). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the strategy rung and a token with the read grant. The platform serves this route.

## Example
The example sends the smallest body that EffectInput allows. The build validates it against the schema of EffectInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/read/effect \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "move": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.read.effect({
    "move": "…"
  });
// answer.body is a Effect. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/read/effect",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "move": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/read/effect")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&EffectInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.read.effect` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Effect`. The [tool's page](/reference/tools/si-read-effect) describes it.


---
title: "read: entity"
description: "an entity, and the two dates to every identifier it ever had, every account, everything it published, every thread, community and gathering, and every connection, across platforms and sources"
section: reference
address: /reference/read/entity
contract: 0476e35e6e275db5
---

# read: entity

an entity, and the two dates to every identifier it ever had, every account, everything it published, every thread, community and gathering, and every connection, across platforms and sources

[figure: The caller sends EntityInput to /v1/read/entity. The platform returns a card whose body is EntitySurface.]

<span class="op-method">POST</span><span class="op-path">/v1/read/entity</span>

The surface of an entity. The call needs the strategy rung under a token with the read grant, and it is served by either, by the size bound.

The route takes [EntityInput](/concepts/entityinput) and returns a card whose body is [EntitySurface](/concepts/entitysurface).



## Request body
The request body is [EntityInput](/concepts/entityinput).



| field | type | required | note |
|---|---|---|---|
| `entity` | `id` | yes |  |



## Response
The route returns a card whose body is [EntitySurface](/concepts/entitysurface). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the strategy rung and a token with the read grant. The platform or the desktop app serves this route.

## Example
The example sends the smallest body that EntityInput allows. The build validates it against the schema of EntityInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/read/entity \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "entity": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.read.entity({
    "entity": "…"
  });
// answer.body is a EntitySurface. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/read/entity",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "entity": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/read/entity")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&EntityInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.read.entity` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/EntitySurface`. The [tool's page](/reference/tools/si-read-entity) describes it.


---
title: "read: estimate"
description: "an estimator, the case to the estimate with its interval, its evidence and its familiarity, or withheld"
section: reference
address: /reference/read/estimate
contract: 0476e35e6e275db5
---

# read: estimate

an estimator, the case to the estimate with its interval, its evidence and its familiarity, or withheld

[figure: The caller sends EstimateInput to /v1/read/estimate. The platform returns a card whose body is Estimate.]

<span class="op-method">POST</span><span class="op-path">/v1/read/estimate</span>

Read an estimate. The call needs the strategy rung under a token with the read grant, and it is served by the platform.

The route takes [EstimateInput](/concepts/estimateinput) and returns a card whose body is [Estimate](/concepts/estimate).



## Request body
The request body is [EstimateInput](/concepts/estimateinput).



| field | type | required | note |
|---|---|---|---|
| `model` | [Model](/concepts/model) | yes |  |
| `case` | [UnitRef](/concepts/unitref) | yes |  |



## Response
The route returns a card whose body is [Estimate](/concepts/estimate). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the strategy rung and a token with the read grant. The platform serves this route.

## Example
The example sends the smallest body that EstimateInput allows. The build validates it against the schema of EstimateInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/read/estimate \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "model": "…", "case": { "id": "…", "kind": "…" } }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.read.estimate({
    "model": "…",
    "case": {
      "id": "…",
      "kind": "…"
    }
  });
// answer.body is a Estimate. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/read/estimate",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "model": "…",
      "case": {
        "id": "…",
        "kind": "…"
      }
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/read/estimate")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&EstimateInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.read.estimate` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Estimate`. The [tool's page](/reference/tools/si-read-estimate) describes it.


---
title: "read: explain catch"
description: "the match to the conditions that admitted it, the words each matched, the observation, and the source"
section: reference
address: /reference/read/explain_catch
contract: 0476e35e6e275db5
---

# read: explain catch

the match to the conditions that admitted it, the words each matched, the observation, and the source

[figure: The caller sends UnitRef to /v1/read/explain_catch. The platform returns a card whose body is Catch.]

<span class="op-method">POST</span><span class="op-path">/v1/read/explain_catch</span>

Explain a match. The call needs the strategy rung under a token with the read grant, and it is served by the platform.

The route takes [UnitRef](/concepts/unitref) and returns a card whose body is [Catch](/concepts/catch).



## Request body
The request body is [UnitRef](/concepts/unitref).



| field | type | required | note |
|---|---|---|---|
| `id` | `id` | yes |  |
| `kind` | [Kind](/concepts/kind) | yes |  |



## Response
The route returns a card whose body is [Catch](/concepts/catch). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the strategy rung and a token with the read grant. The platform serves this route.

## Example
The example sends the smallest body that UnitRef allows. The build validates it against the schema of UnitRef.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/read/explain_catch \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "id": "…", "kind": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.read.explain_catch({
    "id": "…",
    "kind": "…"
  });
// answer.body is a Catch. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/read/explain_catch",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "id": "…",
      "kind": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/read/explain_catch")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&UnitRef { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.read.explain_catch` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Catch`. The [tool's page](/reference/tools/si-read-explain_catch) describes it.


---
title: "read: failed calls"
description: "a tenant to every signed call that did not land, with why, and a way to send it again"
section: reference
address: /reference/read/failed_calls
contract: 0476e35e6e275db5
---

# read: failed calls

a tenant to every signed call that did not land, with why, and a way to send it again

[figure: The caller sends ConnectorsInput to /v1/read/failed_calls. The platform returns a card whose body is [FailedCall].]

<span class="op-method">POST</span><span class="op-path">/v1/read/failed_calls</span>

The calls that failed. The call needs the tenant rung under a token with the read grant, and it is served by the platform.

The route takes [ConnectorsInput](/concepts/connectorsinput) and returns a card whose body is [FailedCall](/concepts/failedcall).



## Request body
The request body is [ConnectorsInput](/concepts/connectorsinput).



| field | type | required | note |
|---|---|---|---|
| `tenant` | `id` | no |  |
| `brand` | `id` | no |  |



## Response
The route returns a card whose body is [FailedCall](/concepts/failedcall). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the tenant rung and a token with the read grant. The platform serves this route.

## Example
The example sends the smallest body that ConnectorsInput allows. The build validates it against the schema of ConnectorsInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/read/failed_calls \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{}'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.read.failed_calls({});
// answer.body is a [FailedCall]. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/read/failed_calls",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={}).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/read/failed_calls")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&ConnectorsInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.read.failed_calls` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/FailedCall`. The [tool's page](/reference/tools/si-read-failed_calls) describes it.


---
title: "read: fit frame"
description: "Reads the frame of one fit search to The answer gives the markets ranked, the offering sculpted for each buyer profile, the tactics proposed to test the fit, the verdict for each market, and the set of options that compares them"
section: reference
address: /reference/read/fit_frame
contract: 0476e35e6e275db5
---

# read: fit frame

Reads the frame of one fit search to The answer gives the markets ranked, the offering sculpted for each buyer profile, the tactics proposed to test the fit, the verdict for each market, and the set of options that compares them

[figure: The caller sends FitFrameInput to /v1/read/fit_frame. The platform returns a card whose body is FitSearchFrame.]

<span class="op-method">POST</span><span class="op-path">/v1/read/fit_frame</span>

Read a search's frame. The call needs the brand rung under a token with the read grant, and it is served by either, by the size bound.

The route takes [FitFrameInput](/concepts/fitframeinput) and returns a card whose body is [FitSearchFrame](/concepts/fitsearchframe).



## Request body
The request body is [FitFrameInput](/concepts/fitframeinput).



| field | type | required | note |
|---|---|---|---|
| `search` | `id` | yes |  |



## Response
The route returns a card whose body is [FitSearchFrame](/concepts/fitsearchframe). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the brand rung and a token with the read grant. The platform or the desktop app serves this route.

## Example
The example sends the smallest body that FitFrameInput allows. The build validates it against the schema of FitFrameInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/read/fit_frame \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "search": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.read.fit_frame({
    "search": "…"
  });
// answer.body is a FitSearchFrame. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/read/fit_frame",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "search": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/read/fit_frame")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&FitFrameInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.read.fit_frame` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/FitSearchFrame`. The [tool's page](/reference/tools/si-read-fit_frame) describes it.


---
title: "read: fit plays"
description: "Reads the tactics that fit one phase of the search, for a vertical or a kind of offering to The answer gives the tactics in the order to run them"
section: reference
address: /reference/read/fit_plays
contract: 0476e35e6e275db5
---

# read: fit plays

Reads the tactics that fit one phase of the search, for a vertical or a kind of offering to The answer gives the tactics in the order to run them

[figure: The caller sends FitPlaysInput to /v1/read/fit_plays. The platform returns a card whose body is [Tactic].]

<span class="op-method">POST</span><span class="op-path">/v1/read/fit_plays</span>

Read the tactics of a phase. The call needs the tenant rung under a token with the read grant, and it is served by either, by the size bound.

The route takes [FitPlaysInput](/concepts/fitplaysinput) and returns a card whose body is [Tactic](/concepts/tactic).



## Request body
The request body is [FitPlaysInput](/concepts/fitplaysinput).



| field | type | required | note |
|---|---|---|---|
| `phase` | `one of find the market \| sculpt the offering \| test the fit \| build a beachhead \| engineer demand \| find demand \| grow in a market \| hedge` | yes |  |
| `vertical` | `id` | no |  |
| `kind_of_offering` | [KindOfOffering](/concepts/kindofoffering) | no |  |



## Response
The route returns a card whose body is [Tactic](/concepts/tactic). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the tenant rung and a token with the read grant. The platform or the desktop app serves this route.

## Example
The example sends the smallest body that FitPlaysInput allows. The build validates it against the schema of FitPlaysInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/read/fit_plays \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "phase": "find the market" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.read.fit_plays({
    "phase": "find the market"
  });
// answer.body is a [Tactic]. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/read/fit_plays",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "phase": "find the market"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/read/fit_plays")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&FitPlaysInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.read.fit_plays` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Tactic`. The [tool's page](/reference/tools/si-read-fit_plays) describes it.


---
title: "read: forecasts"
description: "a play or a tactic, across brands to every forecast with its effect, how well the band held, and the proper score by play, tactic, kind of buyer, framing, actor and content"
section: reference
address: /reference/read/forecasts
contract: 0476e35e6e275db5
---

# read: forecasts

a play or a tactic, across brands to every forecast with its effect, how well the band held, and the proper score by play, tactic, kind of buyer, framing, actor and content

[figure: The caller sends ForecastsInput to /v1/read/forecasts. The platform returns a card whose body is ForecastsAnswer.]

<span class="op-method">POST</span><span class="op-path">/v1/read/forecasts</span>

Read forecasts against effects. The call needs the brand rung under a token with the read grant, and it is served by the platform.

The route takes [ForecastsInput](/concepts/forecastsinput) and returns a card whose body is [ForecastsAnswer](/concepts/forecastsanswer).



## Request body
The request body is [ForecastsInput](/concepts/forecastsinput).



| field | type | required | note |
|---|---|---|---|
| `play` | `id` | no |  |
| `tactic` | [Tactic](/concepts/tactic) | no |  |



## Response
The route returns a card whose body is [ForecastsAnswer](/concepts/forecastsanswer). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the brand rung and a token with the read grant. The platform serves this route.

## Example
The example sends the smallest body that ForecastsInput allows. The build validates it against the schema of ForecastsInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/read/forecasts \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{}'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.read.forecasts({});
// answer.body is a ForecastsAnswer. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/read/forecasts",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={}).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/read/forecasts")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&ForecastsInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.read.forecasts` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/ForecastsAnswer`. The [tool's page](/reference/tools/si-read-forecasts) describes it.


---
title: "read: grounding priors"
description: "a platform, or nothing (`GroundingPriorsInput`) to how often a person supported each kind of suggestion at each breadth, one row per kind, platform and breadth (`GroundingPriors`)"
section: reference
address: /reference/read/grounding_priors
contract: 0476e35e6e275db5
---

# read: grounding priors

a platform, or nothing (`GroundingPriorsInput`) to how often a person supported each kind of suggestion at each breadth, one row per kind, platform and breadth (`GroundingPriors`)

[figure: The caller sends GroundingPriorsInput to /v1/read/grounding_priors. The platform returns a card whose body is GroundingPriors.]

<span class="op-method">POST</span><span class="op-path">/v1/read/grounding_priors</span>

Read the priors of grounding. The call needs the user rung under a token with the read grant, and it is served by the platform.

The route takes [GroundingPriorsInput](/concepts/groundingpriorsinput) and returns a card whose body is [GroundingPriors](/concepts/groundingpriors).



## Request body
The request body is [GroundingPriorsInput](/concepts/groundingpriorsinput).



| field | type | required | note |
|---|---|---|---|
| `platform` | `text` | no |  |



## Response
The route returns a card whose body is [GroundingPriors](/concepts/groundingpriors). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the user rung and a token with the read grant. The platform serves this route.

## Example
The example sends the smallest body that GroundingPriorsInput allows. The build validates it against the schema of GroundingPriorsInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/read/grounding_priors \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{}'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.read.grounding_priors({});
// answer.body is a GroundingPriors. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/read/grounding_priors",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={}).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/read/grounding_priors")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&GroundingPriorsInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.read.grounding_priors` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/GroundingPriors`. The [tool's page](/reference/tools/si-read-grounding_priors) describes it.


---
title: "read: groundings"
description: "one capture's, one entity's, or every grounding in a place to each grounding with its hypotheses"
section: reference
address: /reference/read/groundings
contract: 0476e35e6e275db5
---

# read: groundings

one capture's, one entity's, or every grounding in a place to each grounding with its hypotheses

[figure: The caller sends GroundingsInput to /v1/read/groundings. The platform returns a card whose body is [GroundingAnswer].]

<span class="op-method">POST</span><span class="op-path">/v1/read/groundings</span>

Read groundings. The call needs the user rung under a token with the read grant, and it is served by the platform.

The route takes [GroundingsInput](/concepts/groundingsinput) and returns a card whose body is [GroundingAnswer](/concepts/groundinganswer).



## Request body
The request body is [GroundingsInput](/concepts/groundingsinput).



| field | type | required | note |
|---|---|---|---|
| `capture` | `hash` | no |  |
| `entity` | `id` | no |  |
| `place` | `one of staged \| grounding \| waiting for a person \| committed \| discarded \| all` | no |  |



## Response
The route returns a card whose body is [GroundingAnswer](/concepts/groundinganswer). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the user rung and a token with the read grant. The platform serves this route.

## Example
The example sends the smallest body that GroundingsInput allows. The build validates it against the schema of GroundingsInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/read/groundings \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{}'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.read.groundings({});
// answer.body is a [GroundingAnswer]. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/read/groundings",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={}).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/read/groundings")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&GroundingsInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.read.groundings` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/GroundingAnswer`. The [tool's page](/reference/tools/si-read-groundings) describes it.


---
title: "read: instruction set"
description: "nothing to the set at its current version, assembled"
section: reference
address: /reference/read/instruction_set
contract: 0476e35e6e275db5
---

# read: instruction set

nothing to the set at its current version, assembled

[figure: The caller sends Nothing to /v1/read/instruction_set. The platform returns a card whose body is InstructionSet.]

<span class="op-method">POST</span><span class="op-path">/v1/read/instruction_set</span>

Read the research instruction set. The call needs the user rung under a token with the read grant, and it is served by either, by the size bound.

The route takes an empty body and returns a card whose body is [InstructionSet](/concepts/instructionset).



## Request body
The request body is empty.



## Response
The route returns a card whose body is [InstructionSet](/concepts/instructionset). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the user rung and a token with the read grant. The platform or the desktop app serves this route.

## Example
The example sends an empty body.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/read/instruction_set \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{}'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.read.instruction_set({});
// answer.body is a InstructionSet. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/read/instruction_set",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={}).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/read/instruction_set")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&()).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.read.instruction_set` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/InstructionSet`. The [tool's page](/reference/tools/si-read-instruction_set) describes it.


---
title: "read: intelligence"
description: "a subject and a kind of intelligence to the kind's facts about the subject with their basis, their coverage and their date"
section: reference
address: /reference/read/intelligence
contract: 0476e35e6e275db5
---

# read: intelligence

a subject and a kind of intelligence to the kind's facts about the subject with their basis, their coverage and their date

[figure: The caller sends IntelligenceInput to /v1/read/intelligence. The platform returns a card whose body is IntelligenceAnswer.]

<span class="op-method">POST</span><span class="op-path">/v1/read/intelligence</span>

Read the intelligence of a subject by kind. The call needs the strategy rung under a token with the read grant, and it is served by the platform.

The route takes [IntelligenceInput](/concepts/intelligenceinput) and returns a card whose body is [IntelligenceAnswer](/concepts/intelligenceanswer).



## Request body
The request body is [IntelligenceInput](/concepts/intelligenceinput).



| field | type | required | note |
|---|---|---|---|
| `subject` | `id` | yes |  |
| `kind` | `text` | yes | one of the register's kinds |



## Response
The route returns a card whose body is [IntelligenceAnswer](/concepts/intelligenceanswer). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the strategy rung and a token with the read grant. The platform serves this route.

## Example
The example sends the smallest body that IntelligenceInput allows. The build validates it against the schema of IntelligenceInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/read/intelligence \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "subject": "…", "kind": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.read.intelligence({
    "subject": "…",
    "kind": "…"
  });
// answer.body is a IntelligenceAnswer. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/read/intelligence",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "subject": "…",
      "kind": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/read/intelligence")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&IntelligenceInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.read.intelligence` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/IntelligenceAnswer`. The [tool's page](/reference/tools/si-read-intelligence) describes it.


---
title: "read: invitations"
description: "nothing to the invitations with their states"
section: reference
address: /reference/read/invitations
contract: 0476e35e6e275db5
---

# read: invitations

nothing to the invitations with their states

[figure: The caller sends Nothing to /v1/read/invitations. The platform returns a card whose body is [Invitation].]

<span class="op-method">POST</span><span class="op-path">/v1/read/invitations</span>

Read my tenant's invitations. The call needs the tenant rung under a token with the admin grant, and it is served by the platform.

The route takes an empty body and returns a card whose body is [Invitation](/concepts/invitation).



## Request body
The request body is empty.



## Response
The route returns a card whose body is [Invitation](/concepts/invitation). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the tenant rung and a token with the admin grant. The platform serves this route.

## Example
The example sends an empty body.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/read/invitations \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{}'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.read.invitations({});
// answer.body is a [Invitation]. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/read/invitations",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={}).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/read/invitations")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&()).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.read.invitations` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Invitation`. The [tool's page](/reference/tools/si-read-invitations) describes it.


---
title: "read: invoices"
description: "a period, or nothing to the invoices with their states"
section: reference
address: /reference/read/invoices
contract: 0476e35e6e275db5
---

# read: invoices

a period, or nothing to the invoices with their states

[figure: The caller sends InvoicesInput to /v1/read/invoices. The platform returns a card whose body is [Invoice].]

<span class="op-method">POST</span><span class="op-path">/v1/read/invoices</span>

Read the invoices. The call needs the tenant rung under a token with the read grant, and it is served by the platform.

The route takes [InvoicesInput](/concepts/invoicesinput) and returns a card whose body is [Invoice](/concepts/invoice).



## Request body
The request body is [InvoicesInput](/concepts/invoicesinput).



| field | type | required | note |
|---|---|---|---|
| `period` | [Window](/concepts/window) | no |  |



## Response
The route returns a card whose body is [Invoice](/concepts/invoice). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the tenant rung and a token with the read grant. The platform serves this route.

## Example
The example sends the smallest body that InvoicesInput allows. The build validates it against the schema of InvoicesInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/read/invoices \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{}'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.read.invoices({});
// answer.body is a [Invoice]. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/read/invoices",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={}).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/read/invoices")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&InvoicesInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.read.invoices` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Invoice`. The [tool's page](/reference/tools/si-read-invoices) describes it.


---
title: "read: leads"
description: "Reads the leads of one brand, narrowed by a place, a condition or a user to The answer gives the leads, or the package that holds them"
section: reference
address: /reference/read/leads
contract: 0476e35e6e275db5
---

# read: leads

Reads the leads of one brand, narrowed by a place, a condition or a user to The answer gives the leads, or the package that holds them

[figure: The caller sends LeadsInput to /v1/read/leads. The platform returns a card whose body is [Lead].]

<span class="op-method">POST</span><span class="op-path">/v1/read/leads</span>

Leads. One lead, as its package. The call needs the strategy rung under a token with the read grant, and it is served by either, by the size bound.

The route takes [LeadsInput](/concepts/leadsinput) and returns a card whose body is [Lead](/concepts/lead).



## Request body
The request body is [LeadsInput](/concepts/leadsinput).



| field | type | required | note |
|---|---|---|---|
| `brand` | `id` | yes |  |
| `place` | `text` | no |  |
| `condition` | [LeadCondition](/concepts/leadcondition) | no |  |
| `person` | `id` | no |  |
| `lead` | `id` | no | one lead, as its package |



## Response
The route returns a card whose body is [Lead](/concepts/lead). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the strategy rung and a token with the read grant. The platform or the desktop app serves this route.

## Example
The example sends the smallest body that LeadsInput allows. The build validates it against the schema of LeadsInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/read/leads \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "brand": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.read.leads({
    "brand": "…"
  });
// answer.body is a [Lead]. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/read/leads",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "brand": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/read/leads")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&LeadsInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.read.leads` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Lead`. The [tool's page](/reference/tools/si-read-leads) describes it.


---
title: "read: ledger"
description: "a strategy, the window to every move, action, forecast, effect and impact in order, with the budget spent by kind"
section: reference
address: /reference/read/ledger
contract: 0476e35e6e275db5
---

# read: ledger

a strategy, the window to every move, action, forecast, effect and impact in order, with the budget spent by kind

[figure: The caller sends LedgerInput to /v1/read/ledger. The platform returns a card whose body is Ledger.]

<span class="op-method">POST</span><span class="op-path">/v1/read/ledger</span>

Read a strategy's ledger. The call needs the strategy rung under a token with the read grant, and it is served by either, by the size bound.

The route takes [LedgerInput](/concepts/ledgerinput) and returns a card whose body is [Ledger](/concepts/ledger).



## Request body
The request body is [LedgerInput](/concepts/ledgerinput).



| field | type | required | note |
|---|---|---|---|
| `strategy` | `id` | yes |  |
| `window` | [Window](/concepts/window) | yes |  |



## Response
The route returns a card whose body is [Ledger](/concepts/ledger). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the strategy rung and a token with the read grant. The platform or the desktop app serves this route.

## Example
The example sends the smallest body that LedgerInput allows. The build validates it against the schema of LedgerInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/read/ledger \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "strategy": "…", "window": { "from": "…", "to": "…" } }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.read.ledger({
    "strategy": "…",
    "window": {
      "from": "…",
      "to": "…"
    }
  });
// answer.body is a Ledger. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/read/ledger",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "strategy": "…",
      "window": {
        "from": "…",
        "to": "…"
      }
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/read/ledger")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&LedgerInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.read.ledger` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Ledger`. The [tool's page](/reference/tools/si-read-ledger) describes it.


---
title: "read: lineage"
description: "an artefact to its whole history and footprint, marking unavailable what a store cannot answer"
section: reference
address: /reference/read/lineage
contract: 0476e35e6e275db5
---

# read: lineage

an artefact to its whole history and footprint, marking unavailable what a store cannot answer

[figure: The caller sends LineageInput to /v1/read/lineage. The platform returns a card whose body is Lineage.]

<span class="op-method">POST</span><span class="op-path">/v1/read/lineage</span>

Read lineage. The call needs the strategy rung under a token with the read grant, and it is served by the platform.

The route takes [LineageInput](/concepts/lineageinput) and returns a card whose body is [Lineage](/concepts/lineage).



## Request body
The request body is [LineageInput](/concepts/lineageinput).



| field | type | required | note |
|---|---|---|---|
| `artefact_hash` | `hash` | no |  |
| `unit` | `id` | no |  |



## Response
The route returns a card whose body is [Lineage](/concepts/lineage). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the strategy rung and a token with the read grant. The platform serves this route.

## Example
The example sends the smallest body that LineageInput allows. The build validates it against the schema of LineageInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/read/lineage \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{}'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.read.lineage({});
// answer.body is a Lineage. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/read/lineage",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={}).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/read/lineage")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&LineageInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.read.lineage` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Lineage`. The [tool's page](/reference/tools/si-read-lineage) describes it.


---
title: "read: lookup"
description: "a key: a namespace with a value, or a name with a place, and with a name a breadth."
section: reference
address: /reference/read/lookup
contract: 0476e35e6e275db5
---

# read: lookup

a key: a namespace with a value, or a name with a place, and with a name a breadth.

[figure: The caller sends LookupInput to /v1/read/lookup. The platform returns a card whose body is LookupAnswer.]

<span class="op-method">POST</span><span class="op-path">/v1/read/lookup</span>

Look up. The call needs the strategy rung under a token with the read grant, and it is served by the platform.

The route takes [LookupInput](/concepts/lookupinput) and returns a card whose body is [LookupAnswer](/concepts/lookupanswer).



## Request body
The request body is [LookupInput](/concepts/lookupinput).



| field | type | required | note |
|---|---|---|---|
| `namespace` | `text` | no |  |
| `value` | `text` | no |  |
| `name` | `text` | no |  |
| `place` | `text` | no |  |
| `kind` | [KindOfEntity](/concepts/kindofentity) | no |  |
| `breadth` | `one of exact \| similar \| related \| broad` | no | with a name: the one candidate search of the record at that breadth, by exact keys, names and meaning, in place of the substring match |



## Response
The route returns a card whose body is [LookupAnswer](/concepts/lookupanswer). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the strategy rung and a token with the read grant. The platform serves this route.

## Example
The example sends the smallest body that LookupInput allows. The build validates it against the schema of LookupInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/read/lookup \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{}'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.read.lookup({});
// answer.body is a LookupAnswer. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/read/lookup",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={}).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/read/lookup")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&LookupInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.read.lookup` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/LookupAnswer`. The [tool's page](/reference/tools/si-read-lookup) describes it.


---
title: "read: map"
description: "a brand, and the two dates to the map"
section: reference
address: /reference/read/map
contract: 0476e35e6e275db5
---

# read: map

a brand, and the two dates to the map

[figure: The caller sends MapInput to /v1/read/map. The platform returns a card whose body is Map.]

<span class="op-method">POST</span><span class="op-path">/v1/read/map</span>

Read the map. The call needs the brand rung under a token with the read grant, and it is served by the platform.

The route takes [MapInput](/concepts/mapinput) and returns a card whose body is [Map](/concepts/map).



## Request body
The request body is [MapInput](/concepts/mapinput).



| field | type | required | note |
|---|---|---|---|
| `brand` | `id` | yes |  |



## Response
The route returns a card whose body is [Map](/concepts/map). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the brand rung and a token with the read grant. The platform serves this route.

## Example
The example sends the smallest body that MapInput allows. The build validates it against the schema of MapInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/read/map \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "brand": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.read.map({
    "brand": "…"
  });
// answer.body is a Map. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/read/map",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "brand": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/read/map")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&MapInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.read.map` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Map`. The [tool's page](/reference/tools/si-read-map) describes it.


---
title: "read: market"
description: "a brand, a segment, the window to the four stages, each with its count, value, basis and coverage, and the silent remainder"
section: reference
address: /reference/read/market
contract: 0476e35e6e275db5
---

# read: market

a brand, a segment, the window to the four stages, each with its count, value, basis and coverage, and the silent remainder

[figure: The caller sends MarketInput to /v1/read/market. The platform returns a card whose body is Market.]

<span class="op-method">POST</span><span class="op-path">/v1/read/market</span>

Read a market's stages. The call needs the brand rung under a token with the read grant, and it is served by the platform.

The route takes [MarketInput](/concepts/marketinput) and returns a card whose body is [Market](/concepts/market).



## Request body
The request body is [MarketInput](/concepts/marketinput).



| field | type | required | note |
|---|---|---|---|
| `brand` | `id` | yes |  |
| `segment` | `id` | yes |  |
| `window` | [Window](/concepts/window) | yes |  |



## Response
The route returns a card whose body is [Market](/concepts/market). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the brand rung and a token with the read grant. The platform serves this route.

## Example
The example sends the smallest body that MarketInput allows. The build validates it against the schema of MarketInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/read/market \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "brand": "…", "segment": "…", "window": { "from": "…", "to": "…" } }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.read.market({
    "brand": "…",
    "segment": "…",
    "window": {
      "from": "…",
      "to": "…"
    }
  });
// answer.body is a Market. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/read/market",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "brand": "…",
      "segment": "…",
      "window": {
        "from": "…",
        "to": "…"
      }
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/read/market")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&MarketInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.read.market` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Market`. The [tool's page](/reference/tools/si-read-market) describes it.


---
title: "read: market twin"
description: "Reads one market twin, and the date to read it as of to The answer gives the twin: the model family and template it was instanced from, the participants placed on the chain, the level of every stock as of the date, the simulations run on it in order, and the strategy whose armed plays are its interventions"
section: reference
address: /reference/read/market_twin
contract: 0476e35e6e275db5
---

# read: market twin

Reads one market twin, and the date to read it as of to The answer gives the twin: the model family and template it was instanced from, the participants placed on the chain, the level of every stock as of the date, the simulations run on it in order, and the strategy whose armed plays are its interventions

[figure: The caller sends MarketTwinInput to /v1/read/market_twin. The platform returns a card whose body is MarketTwin.]

<span class="op-method">POST</span><span class="op-path">/v1/read/market_twin</span>

Read the twin of a market. The call needs the brand rung under a token with the read grant, and it is served by either, by the size bound.

The route takes [MarketTwinInput](/concepts/markettwininput) and returns a card whose body is [MarketTwin](/concepts/markettwin).



## Request body
The request body is [MarketTwinInput](/concepts/markettwininput).



| field | type | required | note |
|---|---|---|---|
| `twin` | `id` | yes |  |
| `as_of` | `time` | no |  |



## Response
The route returns a card whose body is [MarketTwin](/concepts/markettwin). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the brand rung and a token with the read grant. The platform or the desktop app serves this route.

## Example
The example sends the smallest body that MarketTwinInput allows. The build validates it against the schema of MarketTwinInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/read/market_twin \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "twin": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.read.market_twin({
    "twin": "…"
  });
// answer.body is a MarketTwin. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/read/market_twin",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "twin": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/read/market_twin")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&MarketTwinInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.read.market_twin` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/MarketTwin`. The [tool's page](/reference/tools/si-read-market_twin) describes it.


---
title: "read: methods"
description: "a question, or nothing to the methods that answer it, or every method, each with its readiness"
section: reference
address: /reference/read/methods
contract: 0476e35e6e275db5
---

# read: methods

a question, or nothing to the methods that answer it, or every method, each with its readiness

[figure: The caller sends MethodsInput to /v1/read/methods. The platform returns a card whose body is [Method].]

<span class="op-method">POST</span><span class="op-path">/v1/read/methods</span>

Read the methods. The call needs the user rung under a token with the read grant, and it is served by either, by the size bound.

The route takes [MethodsInput](/concepts/methodsinput) and returns a card whose body is [Method](/concepts/method).



## Request body
The request body is [MethodsInput](/concepts/methodsinput).



| field | type | required | note |
|---|---|---|---|
| `question` | `text` | no |  |



## Response
The route returns a card whose body is [Method](/concepts/method). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the user rung and a token with the read grant. The platform or the desktop app serves this route.

## Example
The example sends the smallest body that MethodsInput allows. The build validates it against the schema of MethodsInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/read/methods \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{}'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.read.methods({});
// answer.body is a [Method]. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/read/methods",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={}).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/read/methods")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&MethodsInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.read.methods` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Method`. The [tool's page](/reference/tools/si-read-methods) describes it.


---
title: "read: model families"
description: "Reads the model families that fit a vertical or a representation to Each family arrives with what it represents, the substrate it is written over, its solver and its check"
section: reference
address: /reference/read/model_families
contract: 0476e35e6e275db5
---

# read: model families

Reads the model families that fit a vertical or a representation to Each family arrives with what it represents, the substrate it is written over, its solver and its check

[figure: The caller sends ModelFamiliesInput to /v1/read/model_families. The platform returns a card whose body is [ModelFamily].]

<span class="op-method">POST</span><span class="op-path">/v1/read/model_families</span>

Read the model families. The call needs the tenant rung under a token with the read grant, and it is served by either, by the size bound.

The route takes [ModelFamiliesInput](/concepts/modelfamiliesinput) and returns a card whose body is [ModelFamily](/concepts/modelfamily).



## Request body
The request body is [ModelFamiliesInput](/concepts/modelfamiliesinput).



| field | type | required | note |
|---|---|---|---|
| `vertical` | `id` | no |  |
| `representation` | `one of stocks and flows \| a graph of participants and handovers \| a hypergraph of co-presence \| agents with behaviours \| a game of roles` | no |  |



## Response
The route returns a card whose body is [ModelFamily](/concepts/modelfamily). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the tenant rung and a token with the read grant. The platform or the desktop app serves this route.

## Example
The example sends the smallest body that ModelFamiliesInput allows. The build validates it against the schema of ModelFamiliesInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/read/model_families \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{}'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.read.model_families({});
// answer.body is a [ModelFamily]. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/read/model_families",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={}).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/read/model_families")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&ModelFamiliesInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.read.model_families` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/ModelFamily`. The [tool's page](/reference/tools/si-read-model_families) describes it.


---
title: "read: monitor strength"
description: "the monitor and a window to the four numbers, each with its population"
section: reference
address: /reference/read/monitor_strength
contract: 0476e35e6e275db5
---

# read: monitor strength

the monitor and a window to the four numbers, each with its population

[figure: The caller sends MonitorStrengthInput to /v1/read/monitor_strength. The platform returns a card whose body is SignalStrength.]

<span class="op-method">POST</span><span class="op-path">/v1/read/monitor_strength</span>

Read the strength of a monitor. The call needs the strategy rung under a token with the read grant, and it is served by the platform.

The route takes [MonitorStrengthInput](/concepts/monitorstrengthinput) and returns a card whose body is [SignalStrength](/concepts/signalstrength).



## Request body
The request body is [MonitorStrengthInput](/concepts/monitorstrengthinput).



| field | type | required | note |
|---|---|---|---|
| `monitor` | `id` | yes |  |
| `window` | [Window](/concepts/window) | yes |  |



## Response
The route returns a card whose body is [SignalStrength](/concepts/signalstrength). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the strategy rung and a token with the read grant. The platform serves this route.

## Example
The example sends the smallest body that MonitorStrengthInput allows. The build validates it against the schema of MonitorStrengthInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/read/monitor_strength \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "monitor": "…", "window": { "from": "…", "to": "…" } }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.read.monitor_strength({
    "monitor": "…",
    "window": {
      "from": "…",
      "to": "…"
    }
  });
// answer.body is a SignalStrength. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/read/monitor_strength",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "monitor": "…",
      "window": {
        "from": "…",
        "to": "…"
      }
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/read/monitor_strength")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&MonitorStrengthInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.read.monitor_strength` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/SignalStrength`. The [tool's page](/reference/tools/si-read-monitor_strength) describes it.


---
title: "read: page changes"
description: "a `PageChangesInput` to `PageChange` rows for the site or the watch in the window"
section: reference
address: /reference/read/page_changes
contract: 0476e35e6e275db5
---

# read: page changes

a `PageChangesInput` to `PageChange` rows for the site or the watch in the window

[figure: The caller sends PageChangesInput to /v1/read/page_changes. The platform returns a card whose body is [PageChange].]

<span class="op-method">POST</span><span class="op-path">/v1/read/page_changes</span>

Read page changes. The call needs the brand rung under a token with the read grant, and it is served by either, by the size bound.

The route takes [PageChangesInput](/concepts/pagechangesinput) and returns a card whose body is [PageChange](/concepts/pagechange).



## Request body
The request body is [PageChangesInput](/concepts/pagechangesinput).



| field | type | required | note |
|---|---|---|---|
| `site` | `id` | no |  |
| `watch` | `id` | no |  |
| `window` | [Window](/concepts/window) | yes |  |



## Response
The route returns a card whose body is [PageChange](/concepts/pagechange). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the brand rung and a token with the read grant. The platform or the desktop app serves this route.

## Example
The example sends the smallest body that PageChangesInput allows. The build validates it against the schema of PageChangesInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/read/page_changes \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "window": { "from": "…", "to": "…" } }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.read.page_changes({
    "window": {
      "from": "…",
      "to": "…"
    }
  });
// answer.body is a [PageChange]. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/read/page_changes",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "window": {
        "from": "…",
        "to": "…"
      }
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/read/page_changes")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&PageChangesInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.read.page_changes` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/PageChange`. The [tool's page](/reference/tools/si-read-page_changes) describes it.


---
title: "read: parameter"
description: "its name to its value, with its dimension and version"
section: reference
address: /reference/read/parameter
contract: 0476e35e6e275db5
---

# read: parameter

its name to its value, with its dimension and version

[figure: The caller sends ParameterInput to /v1/read/parameter. The platform returns a card whose body is Parameter.]

<span class="op-method">POST</span><span class="op-path">/v1/read/parameter</span>

Read a parameter. The call needs the tenant rung under a token with the read grant, and it is served by the platform.

The route takes [ParameterInput](/concepts/parameterinput) and returns a card whose body is [Parameter](/concepts/parameter).



## Request body
The request body is [ParameterInput](/concepts/parameterinput).



| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `scope` | [Scope](/concepts/scope) | no |  |



## Response
The route returns a card whose body is [Parameter](/concepts/parameter). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the tenant rung and a token with the read grant. The platform serves this route.

## Example
The example sends the smallest body that ParameterInput allows. The build validates it against the schema of ParameterInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/read/parameter \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "name": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.read.parameter({
    "name": "…"
  });
// answer.body is a Parameter. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/read/parameter",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "name": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/read/parameter")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&ParameterInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.read.parameter` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Parameter`. The [tool's page](/reference/tools/si-read-parameter) describes it.


---
title: "read: plan report"
description: "a strategy and a window (`PlanReportInput`) to each play completed, partial or missing, and the items done off plan"
section: reference
address: /reference/read/plan_report
contract: 0476e35e6e275db5
---

# read: plan report

a strategy and a window (`PlanReportInput`) to each play completed, partial or missing, and the items done off plan

[figure: The caller sends PlanReportInput to /v1/read/plan_report. The platform returns a card whose body is PlanReport.]

<span class="op-method">POST</span><span class="op-path">/v1/read/plan_report</span>

Read the report of a plan. The call needs the strategy rung under a token with the read grant, and it is served by the platform.

The route takes [PlanReportInput](/concepts/planreportinput) and returns a card whose body is [PlanReport](/concepts/planreport).



## Request body
The request body is [PlanReportInput](/concepts/planreportinput).



| field | type | required | note |
|---|---|---|---|
| `strategy` | `id` | yes |  |
| `window` | [Window](/concepts/window) | no |  |



## Response
The route returns a card whose body is [PlanReport](/concepts/planreport). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the strategy rung and a token with the read grant. The platform serves this route.

## Example
The example sends the smallest body that PlanReportInput allows. The build validates it against the schema of PlanReportInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/read/plan_report \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "strategy": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.read.plan_report({
    "strategy": "…"
  });
// answer.body is a PlanReport. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/read/plan_report",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "strategy": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/read/plan_report")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&PlanReportInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.read.plan_report` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/PlanReport`. The [tool's page](/reference/tools/si-read-plan_report) describes it.


---
title: "read: policy replay"
description: "a policy row and its version, a strategy and a window (`PolicyReplayInput`) to what the policy would have chosen at every logged decision against what was chosen, and the effects that followed (`PolicyReplay`)"
section: reference
address: /reference/read/policy_replay
contract: 0476e35e6e275db5
---

# read: policy replay

a policy row and its version, a strategy and a window (`PolicyReplayInput`) to what the policy would have chosen at every logged decision against what was chosen, and the effects that followed (`PolicyReplay`)

[figure: The caller sends PolicyReplayInput to /v1/read/policy_replay. The platform returns a card whose body is PolicyReplay.]

<span class="op-method">POST</span><span class="op-path">/v1/read/policy_replay</span>

Replay a policy. The call needs the strategy rung under a token with the read grant, and it is served by the platform.

The route takes [PolicyReplayInput](/concepts/policyreplayinput) and returns a card whose body is [PolicyReplay](/concepts/policyreplay).



## Request body
The request body is [PolicyReplayInput](/concepts/policyreplayinput).



| field | type | required | note |
|---|---|---|---|
| `policy` | [Policy](/concepts/policy) | yes |  |
| `strategy` | `id` | yes |  |
| `window` | [Window](/concepts/window) | no |  |



## Response
The route returns a card whose body is [PolicyReplay](/concepts/policyreplay). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the strategy rung and a token with the read grant. The platform serves this route.

## Example
The example sends the smallest body that PolicyReplayInput allows. The build validates it against the schema of PolicyReplayInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/read/policy_replay \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "policy": "…", "strategy": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.read.policy_replay({
    "policy": "…",
    "strategy": "…"
  });
// answer.body is a PolicyReplay. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/read/policy_replay",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "policy": "…",
      "strategy": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/read/policy_replay")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&PolicyReplayInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.read.policy_replay` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/PolicyReplay`. The [tool's page](/reference/tools/si-read-policy_replay) describes it.


---
title: "read: posture"
description: "a community, the window to open, conditional, closed or unknown, with the two removal rates and the archetype"
section: reference
address: /reference/read/posture
contract: 0476e35e6e275db5
---

# read: posture

a community, the window to open, conditional, closed or unknown, with the two removal rates and the archetype

[figure: The caller sends PostureInput to /v1/read/posture. The platform returns a card whose body is CommunityPosture.]

<span class="op-method">POST</span><span class="op-path">/v1/read/posture</span>

Read a community's posture. The call needs the brand rung under a token with the read grant, and it is served by either, by the size bound.

The route takes [PostureInput](/concepts/postureinput) and returns a card whose body is [CommunityPosture](/concepts/communityposture).



## Request body
The request body is [PostureInput](/concepts/postureinput).



| field | type | required | note |
|---|---|---|---|
| `community` | `id` | yes |  |
| `window` | [Window](/concepts/window) | no |  |



## Response
The route returns a card whose body is [CommunityPosture](/concepts/communityposture). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the brand rung and a token with the read grant. The platform or the desktop app serves this route.

## Example
The example sends the smallest body that PostureInput allows. The build validates it against the schema of PostureInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/read/posture \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "community": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.read.posture({
    "community": "…"
  });
// answer.body is a CommunityPosture. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/read/posture",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "community": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/read/posture")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&PostureInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.read.posture` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/CommunityPosture`. The [tool's page](/reference/tools/si-read-posture) describes it.


---
title: "read: predicate language"
description: "the register's name to its rows with the hash"
section: reference
address: /reference/read/predicate_language
contract: 0476e35e6e275db5
---

# read: predicate language

the register's name to its rows with the hash

[figure: The caller sends Nothing to /v1/read/predicate_language. The platform returns a card whose body is PredicateLanguage.]

<span class="op-method">POST</span><span class="op-path">/v1/read/predicate_language</span>

Read the operators, the comparators, the places, the populations, the kinds of signal, the stages. The call needs the tenant rung under a token with the read grant, and it is served by the platform.

The route takes an empty body and returns a card whose body is [PredicateLanguage](/concepts/predicatelanguage).



## Request body
The request body is empty.



## Response
The route returns a card whose body is [PredicateLanguage](/concepts/predicatelanguage). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the tenant rung and a token with the read grant. The platform serves this route.

## Example
The example sends an empty body.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/read/predicate_language \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{}'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.read.predicate_language({});
// answer.body is a PredicateLanguage. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/read/predicate_language",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={}).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/read/predicate_language")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&()).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.read.predicate_language` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/PredicateLanguage`. The [tool's page](/reference/tools/si-read-predicate_language) describes it.


---
title: "read: propensity"
description: "a lead, a move or a play, and which faces, actors or content or both (`PropensityInput`) to every eligible actor and every fitting content with the chance, its interval, its basis and the policy's odds, and the one the policy would choose (`PropensityAnswer`)"
section: reference
address: /reference/read/propensity
contract: 0476e35e6e275db5
---

# read: propensity

a lead, a move or a play, and which faces, actors or content or both (`PropensityInput`) to every eligible actor and every fitting content with the chance, its interval, its basis and the policy's odds, and the one the policy would choose (`PropensityAnswer`)

[figure: The caller sends PropensityInput to /v1/read/propensity. The platform returns a card whose body is PropensityAnswer.]

<span class="op-method">POST</span><span class="op-path">/v1/read/propensity</span>

Read who and what fits a lead. The call needs the strategy rung under a token with the read grant, and it is served by the platform.

The route takes [PropensityInput](/concepts/propensityinput) and returns a card whose body is [PropensityAnswer](/concepts/propensityanswer).



## Request body
The request body is [PropensityInput](/concepts/propensityinput).



| field | type | required | note |
|---|---|---|---|
| `lead` | `id` | yes |  |
| `move` | `id` | no |  |
| `play` | `id` | no |  |
| `faces` | `[one of actor \| content]` | yes |  |



## Response
The route returns a card whose body is [PropensityAnswer](/concepts/propensityanswer). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the strategy rung and a token with the read grant. The platform serves this route.

## Example
The example sends the smallest body that PropensityInput allows. The build validates it against the schema of PropensityInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/read/propensity \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "lead": "…", "faces": [] }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.read.propensity({
    "lead": "…",
    "faces": []
  });
// answer.body is a PropensityAnswer. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/read/propensity",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "lead": "…",
      "faces": []
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/read/propensity")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&PropensityInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.read.propensity` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/PropensityAnswer`. The [tool's page](/reference/tools/si-read-propensity) describes it.


---
title: "read: proxy"
description: "the proxy and its version, the two dates, and a place to its members as a population, with the raw count, the estimate corrected by the recall and the undercount's interval, its calibration by segment, its coverage by channel, and its co-membership with other proxies; for an aggregate-only proxy the counts alone…"
section: reference
address: /reference/read/proxy
contract: 0476e35e6e275db5
---

# read: proxy

the proxy and its version, the two dates, and a place to its members as a population, with the raw count, the estimate corrected by the recall and the undercount's interval, its calibration by segment, its coverage by channel, and its co-membership with other proxies; for an aggregate-only proxy the counts alone…

[figure: The caller sends ProxyReadInput to /v1/read/proxy. The platform returns a card whose body is ProxyReading.]

<span class="op-method">POST</span><span class="op-path">/v1/read/proxy</span>

Read a proxy. The call needs the strategy rung under a token with the read grant, and it is served by either, by the size bound.

The route takes [ProxyReadInput](/concepts/proxyreadinput) and returns a card whose body is [ProxyReading](/concepts/proxyreading).



## Request body
The request body is [ProxyReadInput](/concepts/proxyreadinput).



| field | type | required | note |
|---|---|---|---|
| `proxy` | `id` | yes |  |
| `window` | [Window](/concepts/window) | no |  |



## Response
The route returns a card whose body is [ProxyReading](/concepts/proxyreading). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the strategy rung and a token with the read grant. The platform or the desktop app serves this route.

## Example
The example sends the smallest body that ProxyReadInput allows. The build validates it against the schema of ProxyReadInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/read/proxy \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "proxy": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.read.proxy({
    "proxy": "…"
  });
// answer.body is a ProxyReading. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/read/proxy",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "proxy": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/read/proxy")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&ProxyReadInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.read.proxy` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/ProxyReading`. The [tool's page](/reference/tools/si-read-proxy) describes it.


---
title: "read: receipts"
description: "the kind, export or erasure to the receipts"
section: reference
address: /reference/read/receipts
contract: 0476e35e6e275db5
---

# read: receipts

the kind, export or erasure to the receipts

[figure: The caller sends ReceiptsInput to /v1/read/receipts. The platform returns a card whose body is Receipts.]

<span class="op-method">POST</span><span class="op-path">/v1/read/receipts</span>

Read the receipts. The call needs the tenant rung under a token with the admin grant, and it is served by the platform.

The route takes [ReceiptsInput](/concepts/receiptsinput) and returns a card whose body is [Receipts](/concepts/receipts).



## Request body
The request body is [ReceiptsInput](/concepts/receiptsinput).



| field | type | required | note |
|---|---|---|---|
| `kind` | `one of export \| erasure` | yes |  |



## Response
The route returns a card whose body is [Receipts](/concepts/receipts). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the tenant rung and a token with the admin grant. The platform serves this route.

## Example
The example sends the smallest body that ReceiptsInput allows. The build validates it against the schema of ReceiptsInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/read/receipts \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "kind": "export" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.read.receipts({
    "kind": "export"
  });
// answer.body is a Receipts. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/read/receipts",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "kind": "export"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/read/receipts")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&ReceiptsInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.read.receipts` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Receipts`. The [tool's page](/reference/tools/si-read-receipts) describes it.


---
title: "read: register"
description: "its name, and a version or *current* to its rows, and the hash"
section: reference
address: /reference/read/register
contract: 0476e35e6e275db5
---

# read: register

its name, and a version or *current* to its rows, and the hash

[figure: The caller sends RegisterInput to /v1/read/register. The platform returns a card whose body is RegisterAnswer.]

<span class="op-method">POST</span><span class="op-path">/v1/read/register</span>

Read a register. The call needs the tenant rung under a token with the read grant, and it is served by the platform.

The route takes [RegisterInput](/concepts/registerinput) and returns a card whose body is [RegisterAnswer](/concepts/registeranswer).



## Request body
The request body is [RegisterInput](/concepts/registerinput).



| field | type | required | note |
|---|---|---|---|
| `register` | `text` | yes |  |
| `name` | `text` | no | is this name registered |



## Response
The route returns a card whose body is [RegisterAnswer](/concepts/registeranswer). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the tenant rung and a token with the read grant. The platform serves this route.

## Example
The example sends the smallest body that RegisterInput allows. The build validates it against the schema of RegisterInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/read/register \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "register": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.read.register({
    "register": "…"
  });
// answer.body is a RegisterAnswer. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/read/register",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "register": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/read/register")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&RegisterInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.read.register` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/RegisterAnswer`. The [tool's page](/reference/tools/si-read-register) describes it.


---
title: "read: registered"
description: "a register and a name to the row, or nothing"
section: reference
address: /reference/read/registered
contract: 0476e35e6e275db5
---

# read: registered

a register and a name to the row, or nothing

[figure: The caller sends RegisterInput to /v1/read/registered. The platform returns a card whose body is RegisterAnswer.]

<span class="op-method">POST</span><span class="op-path">/v1/read/registered</span>

Is this name registered. The call needs the tenant rung under a token with the read grant, and it is served by the platform.

The route takes [RegisterInput](/concepts/registerinput) and returns a card whose body is [RegisterAnswer](/concepts/registeranswer).



## Request body
The request body is [RegisterInput](/concepts/registerinput).



| field | type | required | note |
|---|---|---|---|
| `register` | `text` | yes |  |
| `name` | `text` | no | is this name registered |



## Response
The route returns a card whose body is [RegisterAnswer](/concepts/registeranswer). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the tenant rung and a token with the read grant. The platform serves this route.

## Example
The example sends the smallest body that RegisterInput allows. The build validates it against the schema of RegisterInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/read/registered \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "register": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.read.registered({
    "register": "…"
  });
// answer.body is a RegisterAnswer. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/read/registered",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "register": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/read/registered")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&RegisterInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.read.registered` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/RegisterAnswer`. The [tool's page](/reference/tools/si-read-registered) describes it.


---
title: "read: roles"
description: "nothing, or one role to the register of roles: each role's side, what it does, what it hands on, which connection holds it, and whether its holder can be a lead"
section: reference
address: /reference/read/roles
contract: 0476e35e6e275db5
---

# read: roles

nothing, or one role to the register of roles: each role's side, what it does, what it hands on, which connection holds it, and whether its holder can be a lead

[figure: The caller sends RolesInput to /v1/read/roles. The platform returns a card whose body is [RoleAroundADecision].]

<span class="op-method">POST</span><span class="op-path">/v1/read/roles</span>

Read the roles. The call needs the brand rung under a token with the read grant, and it is served by either, by the size bound.

The route takes [RolesInput](/concepts/rolesinput) and returns a card whose body is [RoleAroundADecision](/concepts/rolearoundadecision).



## Request body
The request body is [RolesInput](/concepts/rolesinput).



| field | type | required | note |
|---|---|---|---|
| `role` | `text` | no |  |



## Response
The route returns a card whose body is [RoleAroundADecision](/concepts/rolearoundadecision). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the brand rung and a token with the read grant. The platform or the desktop app serves this route.

## Example
The example sends the smallest body that RolesInput allows. The build validates it against the schema of RolesInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/read/roles \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{}'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.read.roles({});
// answer.body is a [RoleAroundADecision]. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/read/roles",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={}).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/read/roles")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&RolesInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.read.roles` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/RoleAroundADecision`. The [tool's page](/reference/tools/si-read-roles) describes it.


---
title: "read: scrape runs"
description: "a `ScrapeRunsInput` to `ScrapeRun` rows with pages, rows, bytes, cost and time"
section: reference
address: /reference/read/scrape_runs
contract: 0476e35e6e275db5
---

# read: scrape runs

a `ScrapeRunsInput` to `ScrapeRun` rows with pages, rows, bytes, cost and time

[figure: The caller sends ScrapeRunsInput to /v1/read/scrape_runs. The platform returns a card whose body is [ScrapeRun].]

<span class="op-method">POST</span><span class="op-path">/v1/read/scrape_runs</span>

Read scrape runs. The call needs the brand rung under a token with the read grant, and it is served by either, by the size bound.

The route takes [ScrapeRunsInput](/concepts/scraperunsinput) and returns a card whose body is [ScrapeRun](/concepts/scraperun).



## Request body
The request body is [ScrapeRunsInput](/concepts/scraperunsinput).



| field | type | required | note |
|---|---|---|---|
| `template` | `id` | yes |  |
| `window` | [Window](/concepts/window) | yes |  |



## Response
The route returns a card whose body is [ScrapeRun](/concepts/scraperun). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the brand rung and a token with the read grant. The platform or the desktop app serves this route.

## Example
The example sends the smallest body that ScrapeRunsInput allows. The build validates it against the schema of ScrapeRunsInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/read/scrape_runs \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "template": "…", "window": { "from": "…", "to": "…" } }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.read.scrape_runs({
    "template": "…",
    "window": {
      "from": "…",
      "to": "…"
    }
  });
// answer.body is a [ScrapeRun]. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/read/scrape_runs",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "template": "…",
      "window": {
        "from": "…",
        "to": "…"
      }
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/read/scrape_runs")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&ScrapeRunsInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.read.scrape_runs` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/ScrapeRun`. The [tool's page](/reference/tools/si-read-scrape_runs) describes it.


---
title: "read: signals"
description: "a monitor, a subject, a kind or a strategy, and a window to the facts, with the coverage and the count not evaluable for the same window"
section: reference
address: /reference/read/signals
contract: 0476e35e6e275db5
---

# read: signals

a monitor, a subject, a kind or a strategy, and a window to the facts, with the coverage and the count not evaluable for the same window

[figure: The caller sends SignalsInput to /v1/read/signals. The platform returns a card whose body is SignalsAnswer.]

<span class="op-method">POST</span><span class="op-path">/v1/read/signals</span>

Read matches. Read signals. The call needs the strategy rung under a token with the read grant, and it is served by either, by the size bound.

The route takes [SignalsInput](/concepts/signalsinput) and returns a card whose body is [SignalsAnswer](/concepts/signalsanswer).



## Request body
The request body is [SignalsInput](/concepts/signalsinput).



| field | type | required | note |
|---|---|---|---|
| `monitor` | `id` | no |  |
| `subject` | `id` | no |  |
| `kind` | [KindOfSignal](/concepts/kindofsignal) | no |  |
| `strategy` | `id` | no |  |
| `window` | [Window](/concepts/window) | yes |  |
| `catches` | `bool` | no | read catches instead |



## Response
The route returns a card whose body is [SignalsAnswer](/concepts/signalsanswer). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the strategy rung and a token with the read grant. The platform or the desktop app serves this route.

## Example
The example sends the smallest body that SignalsInput allows. The build validates it against the schema of SignalsInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/read/signals \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "window": { "from": "…", "to": "…" } }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.read.signals({
    "window": {
      "from": "…",
      "to": "…"
    }
  });
// answer.body is a SignalsAnswer. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/read/signals",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "window": {
        "from": "…",
        "to": "…"
      }
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/read/signals")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&SignalsInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.read.signals` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/SignalsAnswer`. The [tool's page](/reference/tools/si-read-signals) describes it.


---
title: "read: simulation frame"
description: "Reads the frame of one simulation to The answer gives the trajectory of every stock, the gain of every loop, the sensitivity to every intervention, and the set of options that compares strategies laid over the same template"
section: reference
address: /reference/read/simulation_frame
contract: 0476e35e6e275db5
---

# read: simulation frame

Reads the frame of one simulation to The answer gives the trajectory of every stock, the gain of every loop, the sensitivity to every intervention, and the set of options that compares strategies laid over the same template

[figure: The caller sends SimulationFrameInput to /v1/read/simulation_frame. The platform returns a card whose body is MarketSimulationFrame.]

<span class="op-method">POST</span><span class="op-path">/v1/read/simulation_frame</span>

Read a simulation's frame. The call needs the brand rung under a token with the read grant, and it is served by either, by the size bound.

The route takes [SimulationFrameInput](/concepts/simulationframeinput) and returns a card whose body is [MarketSimulationFrame](/concepts/marketsimulationframe).



## Request body
The request body is [SimulationFrameInput](/concepts/simulationframeinput).



| field | type | required | note |
|---|---|---|---|
| `simulation` | `id` | yes |  |



## Response
The route returns a card whose body is [MarketSimulationFrame](/concepts/marketsimulationframe). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the brand rung and a token with the read grant. The platform or the desktop app serves this route.

## Example
The example sends the smallest body that SimulationFrameInput allows. The build validates it against the schema of SimulationFrameInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/read/simulation_frame \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "simulation": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.read.simulation_frame({
    "simulation": "…"
  });
// answer.body is a MarketSimulationFrame. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/read/simulation_frame",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "simulation": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/read/simulation_frame")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&SimulationFrameInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.read.simulation_frame` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/MarketSimulationFrame`. The [tool's page](/reference/tools/si-read-simulation_frame) describes it.


---
title: "read: source procedure"
description: "a source to its procedure at its version, the date of its last reading and whether it is stale"
section: reference
address: /reference/read/source_procedure
contract: 0476e35e6e275db5
---

# read: source procedure

a source to its procedure at its version, the date of its last reading and whether it is stale

[figure: The caller sends SourceProcedureInput to /v1/read/source_procedure. The platform returns a card whose body is SourceProcedure.]

<span class="op-method">POST</span><span class="op-path">/v1/read/source_procedure</span>

Read the procedure of a source. The call needs the tenant rung under a token with the read grant, and it is served by either, by the size bound.

The route takes [SourceProcedureInput](/concepts/sourceprocedureinput) and returns a card whose body is [SourceProcedure](/concepts/sourceprocedure).



## Request body
The request body is [SourceProcedureInput](/concepts/sourceprocedureinput).



| field | type | required | note |
|---|---|---|---|
| `source` | `id` | yes |  |



## Response
The route returns a card whose body is [SourceProcedure](/concepts/sourceprocedure). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the tenant rung and a token with the read grant. The platform or the desktop app serves this route.

## Example
The example sends the smallest body that SourceProcedureInput allows. The build validates it against the schema of SourceProcedureInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/read/source_procedure \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "source": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.read.source_procedure({
    "source": "…"
  });
// answer.body is a SourceProcedure. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/read/source_procedure",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "source": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/read/source_procedure")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&SourceProcedureInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.read.source_procedure` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/SourceProcedure`. The [tool's page](/reference/tools/si-read-source_procedure) describes it.


---
title: "read: speed to lead"
description: "Reads the delay from delivery to the first touch for one brand, over a window to The answer gives the measure's readings, with the population each was read over"
section: reference
address: /reference/read/speed_to_lead
contract: 0476e35e6e275db5
---

# read: speed to lead

Reads the delay from delivery to the first touch for one brand, over a window to The answer gives the measure's readings, with the population each was read over

[figure: The caller sends SpeedToLeadInput to /v1/read/speed_to_lead. The platform returns a card whose body is SpeedToLead.]

<span class="op-method">POST</span><span class="op-path">/v1/read/speed_to_lead</span>

Speed to lead. The call needs the brand rung under a token with the read grant, and it is served by the platform.

The route takes [SpeedToLeadInput](/concepts/speedtoleadinput) and returns a card whose body is [SpeedToLead](/concepts/speedtolead).



## Request body
The request body is [SpeedToLeadInput](/concepts/speedtoleadinput).



| field | type | required | note |
|---|---|---|---|
| `brand` | `id` | yes |  |
| `window` | [Window](/concepts/window) | yes |  |



## Response
The route returns a card whose body is [SpeedToLead](/concepts/speedtolead). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the brand rung and a token with the read grant. The platform serves this route.

## Example
The example sends the smallest body that SpeedToLeadInput allows. The build validates it against the schema of SpeedToLeadInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/read/speed_to_lead \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "brand": "…", "window": { "from": "…", "to": "…" } }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.read.speed_to_lead({
    "brand": "…",
    "window": {
      "from": "…",
      "to": "…"
    }
  });
// answer.body is a SpeedToLead. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/read/speed_to_lead",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "brand": "…",
      "window": {
        "from": "…",
        "to": "…"
      }
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/read/speed_to_lead")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&SpeedToLeadInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.read.speed_to_lead` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/SpeedToLead`. The [tool's page](/reference/tools/si-read-speed_to_lead) describes it.


---
title: "read: strategy"
description: "a strategy, as of a date (`StrategyReadInput`) to the `Strategy` with its life, its game, its graph of plays with each play's class and its reading, the experiments' shares and the frame of its last simulation"
section: reference
address: /reference/read/strategy
contract: 0476e35e6e275db5
---

# read: strategy

a strategy, as of a date (`StrategyReadInput`) to the `Strategy` with its life, its game, its graph of plays with each play's class and its reading, the experiments' shares and the frame of its last simulation

[figure: The caller sends StrategyReadInput to /v1/read/strategy. The platform returns a card whose body is Strategy.]

<span class="op-method">POST</span><span class="op-path">/v1/read/strategy</span>

Read a strategy. The call needs the strategy rung under a token with the read grant, and it is served by the platform.

The route takes [StrategyReadInput](/concepts/strategyreadinput) and returns a card whose body is [Strategy](/concepts/strategy).



## Request body
The request body is [StrategyReadInput](/concepts/strategyreadinput).



| field | type | required | note |
|---|---|---|---|
| `strategy` | `id` | yes |  |
| `as_of` | `date` | no |  |



## Response
The route returns a card whose body is [Strategy](/concepts/strategy). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the strategy rung and a token with the read grant. The platform serves this route.

## Example
The example sends the smallest body that StrategyReadInput allows. The build validates it against the schema of StrategyReadInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/read/strategy \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "strategy": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.read.strategy({
    "strategy": "…"
  });
// answer.body is a Strategy. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/read/strategy",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "strategy": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/read/strategy")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&StrategyReadInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.read.strategy` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Strategy`. The [tool's page](/reference/tools/si-read-strategy) describes it.


---
title: "read: systems models"
description: "Reads the systems models that fit one vertical or one kind of offering to Each template arrives with its readiness and the defect it carries named"
section: reference
address: /reference/read/systems_models
contract: 0476e35e6e275db5
---

# read: systems models

Reads the systems models that fit one vertical or one kind of offering to Each template arrives with its readiness and the defect it carries named

[figure: The caller sends SystemsModelsInput to /v1/read/systems_models. The platform returns a card whose body is [SystemsModelTemplate].]

<span class="op-method">POST</span><span class="op-path">/v1/read/systems_models</span>

Read the systems models. The call needs the tenant rung under a token with the read grant, and it is served by either, by the size bound.

The route takes [SystemsModelsInput](/concepts/systemsmodelsinput) and returns a card whose body is [SystemsModelTemplate](/concepts/systemsmodeltemplate).



## Request body
The request body is [SystemsModelsInput](/concepts/systemsmodelsinput).



| field | type | required | note |
|---|---|---|---|
| `vertical` | `id` | no |  |
| `kind_of_offering` | [KindOfOffering](/concepts/kindofoffering) | no |  |



## Response
The route returns a card whose body is [SystemsModelTemplate](/concepts/systemsmodeltemplate). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the tenant rung and a token with the read grant. The platform or the desktop app serves this route.

## Example
The example sends the smallest body that SystemsModelsInput allows. The build validates it against the schema of SystemsModelsInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/read/systems_models \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{}'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.read.systems_models({});
// answer.body is a [SystemsModelTemplate]. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/read/systems_models",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={}).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/read/systems_models")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&SystemsModelsInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.read.systems_models` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/SystemsModelTemplate`. The [tool's page](/reference/tools/si-read-systems_models) describes it.


---
title: "read: trajectory"
description: "a strategy or one move, and a window (`TrajectoryInput`) to plan item to grounded move to outcome: each move with the items that carried it out, their readings and its effect"
section: reference
address: /reference/read/trajectory
contract: 0476e35e6e275db5
---

# read: trajectory

a strategy or one move, and a window (`TrajectoryInput`) to plan item to grounded move to outcome: each move with the items that carried it out, their readings and its effect

[figure: The caller sends TrajectoryInput to /v1/read/trajectory. The platform returns a card whose body is Trajectory.]

<span class="op-method">POST</span><span class="op-path">/v1/read/trajectory</span>

Read a trajectory. The call needs the strategy rung under a token with the read grant, and it is served by the platform.

The route takes [TrajectoryInput](/concepts/trajectoryinput) and returns a card whose body is [Trajectory](/concepts/trajectory).



## Request body
The request body is [TrajectoryInput](/concepts/trajectoryinput).



| field | type | required | note |
|---|---|---|---|
| `strategy` | `id` | no |  |
| `move` | `id` | no |  |
| `window` | [Window](/concepts/window) | no |  |



## Response
The route returns a card whose body is [Trajectory](/concepts/trajectory). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the strategy rung and a token with the read grant. The platform serves this route.

## Example
The example sends the smallest body that TrajectoryInput allows. The build validates it against the schema of TrajectoryInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/read/trajectory \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{}'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.read.trajectory({});
// answer.body is a Trajectory. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/read/trajectory",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={}).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/read/trajectory")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&TrajectoryInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.read.trajectory` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Trajectory`. The [tool's page](/reference/tools/si-read-trajectory) describes it.


---
title: "read: under test"
description: "a subject or a scope, and the two dates to every hypothesis about it with its standing, its evidence for and against, the tests run and the tests owed, and what would settle each"
section: reference
address: /reference/read/under_test
contract: 0476e35e6e275db5
---

# read: under test

a subject or a scope, and the two dates to every hypothesis about it with its standing, its evidence for and against, the tests run and the tests owed, and what would settle each

[figure: The caller sends UnderTestInput to /v1/read/under_test. The platform returns a card whose body is [Hypothesis].]

<span class="op-method">POST</span><span class="op-path">/v1/read/under_test</span>

Read what is under test. The call needs the strategy rung under a token with the read grant, and it is served by either, by the size bound.

The route takes [UnderTestInput](/concepts/undertestinput) and returns a card whose body is [Hypothesis](/concepts/hypothesis).



## Request body
The request body is [UnderTestInput](/concepts/undertestinput).



| field | type | required | note |
|---|---|---|---|
| `about` | [UnitRef](/concepts/unitref) | no |  |
| `scope` | [Scope](/concepts/scope) | no |  |
| `standing` | `one of under test \| supported \| refuted \| cannot tell \| all` | no |  |



## Response
The route returns a card whose body is [Hypothesis](/concepts/hypothesis). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the strategy rung and a token with the read grant. The platform or the desktop app serves this route.

## Example
The example sends the smallest body that UnderTestInput allows. The build validates it against the schema of UnderTestInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/read/under_test \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{}'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.read.under_test({});
// answer.body is a [Hypothesis]. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/read/under_test",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={}).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/read/under_test")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&UnderTestInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.read.under_test` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Hypothesis`. The [tool's page](/reference/tools/si-read-under_test) describes it.


---
title: "read: unit"
description: "the kind, the id, the caller to the unit"
section: reference
address: /reference/read/unit
contract: 0476e35e6e275db5
---

# read: unit

the kind, the id, the caller to the unit

[figure: The caller sends UnitRef to /v1/read/unit. The platform returns a card whose body is Unit.]

<span class="op-method">POST</span><span class="op-path">/v1/read/unit</span>

Read a unit. The call needs the strategy rung under a token with the read grant, and it is served by the platform.

The route takes [UnitRef](/concepts/unitref) and returns a card whose body is [Unit](/concepts/unit).



## Request body
The request body is [UnitRef](/concepts/unitref).



| field | type | required | note |
|---|---|---|---|
| `id` | `id` | yes |  |
| `kind` | [Kind](/concepts/kind) | yes |  |



## Response
The route returns a card whose body is [Unit](/concepts/unit). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the strategy rung and a token with the read grant. The platform serves this route.

## Example
The example sends the smallest body that UnitRef allows. The build validates it against the schema of UnitRef.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/read/unit \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "id": "…", "kind": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.read.unit({
    "id": "…",
    "kind": "…"
  });
// answer.body is a Unit. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/read/unit",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "id": "…",
      "kind": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/read/unit")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&UnitRef { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.read.unit` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Unit`. The [tool's page](/reference/tools/si-read-unit) describes it.


---
title: "read: usage statement"
description: "a period to the tenant's usage of the period by kind, priced, against the plan"
section: reference
address: /reference/read/usage_statement
contract: 0476e35e6e275db5
---

# read: usage statement

a period to the tenant's usage of the period by kind, priced, against the plan

[figure: The caller sends UsageStatementInput to /v1/read/usage_statement. The platform returns a card whose body is UsageStatement.]

<span class="op-method">POST</span><span class="op-path">/v1/read/usage_statement</span>

Read the usage statement. The call needs the tenant rung under a token with the read grant, and it is served by the platform.

The route takes [UsageStatementInput](/concepts/usagestatementinput) and returns a card whose body is [UsageStatement](/concepts/usagestatement).



## Request body
The request body is [UsageStatementInput](/concepts/usagestatementinput).



| field | type | required | note |
|---|---|---|---|
| `period` | [Window](/concepts/window) | yes |  |



## Response
The route returns a card whose body is [UsageStatement](/concepts/usagestatement). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the tenant rung and a token with the read grant. The platform serves this route.

## Example
The example sends the smallest body that UsageStatementInput allows. The build validates it against the schema of UsageStatementInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/read/usage_statement \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "period": { "from": "…", "to": "…" } }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.read.usage_statement({
    "period": {
      "from": "…",
      "to": "…"
    }
  });
// answer.body is a UsageStatement. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/read/usage_statement",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "period": {
        "from": "…",
        "to": "…"
      }
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/read/usage_statement")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&UsageStatementInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.read.usage_statement` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/UsageStatement`. The [tool's page](/reference/tools/si-read-usage_statement) describes it.


---
title: "read: value chain"
description: "Reads the value chain of one vertical, with the brand whose participants are placed on it to The answer gives the chain's stocks and handovers with their counts, the participants on each stock, and the loops the templates name over it"
section: reference
address: /reference/read/value_chain
contract: 0476e35e6e275db5
---

# read: value chain

Reads the value chain of one vertical, with the brand whose participants are placed on it to The answer gives the chain's stocks and handovers with their counts, the participants on each stock, and the loops the templates name over it

[figure: The caller sends ValueChainInput to /v1/read/value_chain. The platform returns a card whose body is ValueChain.]

<span class="op-method">POST</span><span class="op-path">/v1/read/value_chain</span>

Read the value chain. The call needs the brand rung under a token with the read grant, and it is served by either, by the size bound.

The route takes [ValueChainInput](/concepts/valuechaininput) and returns a card whose body is [ValueChain](/concepts/valuechain).



## Request body
The request body is [ValueChainInput](/concepts/valuechaininput).



| field | type | required | note |
|---|---|---|---|
| `vertical` | `id` | yes |  |
| `brand` | `id` | no |  |
| `segment` | `id` | no |  |



## Response
The route returns a card whose body is [ValueChain](/concepts/valuechain). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the brand rung and a token with the read grant. The platform or the desktop app serves this route.

## Example
The example sends the smallest body that ValueChainInput allows. The build validates it against the schema of ValueChainInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/read/value_chain \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "vertical": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.read.value_chain({
    "vertical": "…"
  });
// answer.body is a ValueChain. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/read/value_chain",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "vertical": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/read/value_chain")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&ValueChainInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.read.value_chain` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/ValueChain`. The [tool's page](/reference/tools/si-read-value_chain) describes it.


---
title: "read: vertical"
description: "the vertical, or a brand whose vertical is meant to its chain by side with every stock's count and basis, its roles, its segments, its templates, its words and its rules"
section: reference
address: /reference/read/vertical
contract: 0476e35e6e275db5
---

# read: vertical

the vertical, or a brand whose vertical is meant to its chain by side with every stock's count and basis, its roles, its segments, its templates, its words and its rules

[figure: The caller sends VerticalInput to /v1/read/vertical. The platform returns a card whose body is Vertical.]

<span class="op-method">POST</span><span class="op-path">/v1/read/vertical</span>

Read a vertical. The call needs the brand rung under a token with the read grant, and it is served by either, by the size bound.

The route takes [VerticalInput](/concepts/verticalinput) and returns a card whose body is [Vertical](/concepts/vertical).



## Request body
The request body is [VerticalInput](/concepts/verticalinput).



| field | type | required | note |
|---|---|---|---|
| `vertical` | `id` | no |  |
| `brand` | `id` | no |  |



## Response
The route returns a card whose body is [Vertical](/concepts/vertical). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the brand rung and a token with the read grant. The platform or the desktop app serves this route.

## Example
The example sends the smallest body that VerticalInput allows. The build validates it against the schema of VerticalInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/read/vertical \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{}'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.read.vertical({});
// answer.body is a Vertical. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/read/vertical",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={}).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/read/vertical")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&VerticalInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.read.vertical` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Vertical`. The [tool's page](/reference/tools/si-read-vertical) describes it.


---
title: "read: why"
description: "any unit to the chain of reasons, from this unit back to its first cause"
section: reference
address: /reference/read/why
contract: 0476e35e6e275db5
---

# read: why

any unit to the chain of reasons, from this unit back to its first cause

[figure: The caller sends WhyInput to /v1/read/why. The platform returns a card whose body is WhyAnswer.]

<span class="op-method">POST</span><span class="op-path">/v1/read/why</span>

Why is this not ready; why is this not ready. The call needs the user rung under a token with the read grant, and it is served by the platform.

The route takes [WhyInput](/concepts/whyinput) and returns a card whose body is [WhyAnswer](/concepts/whyanswer).



## Request body
The request body is [WhyInput](/concepts/whyinput).



| field | type | required | note |
|---|---|---|---|
| `unit` | [UnitRef](/concepts/unitref) | yes |  |



## Response
The route returns a card whose body is [WhyAnswer](/concepts/whyanswer). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the user rung and a token with the read grant. The platform serves this route.

## Example
The example sends the smallest body that WhyInput allows. The build validates it against the schema of WhyInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/read/why \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "unit": { "id": "…", "kind": "…" } }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.read.why({
    "unit": {
      "id": "…",
      "kind": "…"
    }
  });
// answer.body is a WhyAnswer. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/read/why",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "unit": {
        "id": "…",
        "kind": "…"
      }
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/read/why")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&WhyInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.read.why` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/WhyAnswer`. The [tool's page](/reference/tools/si-read-why) describes it.


---
title: "read: withheld"
description: "Reads the withheld count for one brand or one tenant to The answer gives the count by buyer profile and temperature, with the period and the limit it was read against"
section: reference
address: /reference/read/withheld
contract: 0476e35e6e275db5
---

# read: withheld

Reads the withheld count for one brand or one tenant to The answer gives the count by buyer profile and temperature, with the period and the limit it was read against

[figure: The caller sends WithheldInput to /v1/read/withheld. The platform returns a card whose body is WithheldCount.]

<span class="op-method">POST</span><span class="op-path">/v1/read/withheld</span>

The withheld count. The call needs the brand rung under a token with the read grant, and it is served by the platform.

The route takes [WithheldInput](/concepts/withheldinput) and returns a card whose body is [WithheldCount](/concepts/withheldcount).



## Request body
The request body is [WithheldInput](/concepts/withheldinput).



| field | type | required | note |
|---|---|---|---|
| `brand` | `id` | no |  |
| `tenant` | `id` | no |  |
| `period` | [Window](/concepts/window) | yes |  |



## Response
The route returns a card whose body is [WithheldCount](/concepts/withheldcount). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the brand rung and a token with the read grant. The platform serves this route.

## Example
The example sends the smallest body that WithheldInput allows. The build validates it against the schema of WithheldInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/read/withheld \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "period": { "from": "…", "to": "…" } }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.read.withheld({
    "period": {
      "from": "…",
      "to": "…"
    }
  });
// answer.body is a WithheldCount. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/read/withheld",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "period": {
        "from": "…",
        "to": "…"
      }
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/read/withheld")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&WithheldInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.read.withheld` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/WithheldCount`. The [tool's page](/reference/tools/si-read-withheld) describes it.


---
title: "view: capabilities"
description: "nothing to the page"
section: reference
address: /reference/view/capabilities
contract: 0476e35e6e275db5
---

# view: capabilities

nothing to the page

[figure: The caller sends Nothing to /v1/view/capabilities. The platform returns a card whose body is CapabilitiesPage.]

<span class="op-method">POST</span><span class="op-path">/v1/view/capabilities</span>

Capabilities; the page of capabilities. The call needs the user rung under a token with the read grant, and it is served by the platform.

The route takes an empty body and returns a card whose body is [CapabilitiesPage](/concepts/capabilitiespage).



## Request body
The request body is empty.



## Response
The route returns a card whose body is [CapabilitiesPage](/concepts/capabilitiespage). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the user rung and a token with the read grant. The platform serves this route.

## Example
The example sends an empty body.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/view/capabilities \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{}'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.view.capabilities({});
// answer.body is a CapabilitiesPage. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/view/capabilities",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={}).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/view/capabilities")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&()).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.view.capabilities` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/CapabilitiesPage`. The [tool's page](/reference/tools/si-view-capabilities) describes it.


---
title: "view: journey"
description: "a unit's id to its hops, back and forward"
section: reference
address: /reference/view/journey
contract: 0476e35e6e275db5
---

# view: journey

a unit's id to its hops, back and forward

[figure: The caller sends JourneyInput to /v1/view/journey. The platform returns a card whose body is Journey.]

<span class="op-method">POST</span><span class="op-path">/v1/view/journey</span>

Journey. The call needs the user rung under a token with the read grant, and it is served by the platform.

The route takes [JourneyInput](/concepts/journeyinput) and returns a card whose body is [Journey](/concepts/journey).



## Request body
The request body is [JourneyInput](/concepts/journeyinput).



| field | type | required | note |
|---|---|---|---|
| `unit` | [UnitRef](/concepts/unitref) | yes |  |
| `depth` | `count` | no |  |



## Response
The route returns a card whose body is [Journey](/concepts/journey). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the user rung and a token with the read grant. The platform serves this route.

## Example
The example sends the smallest body that JourneyInput allows. The build validates it against the schema of JourneyInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/view/journey \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "unit": { "id": "…", "kind": "…" } }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.view.journey({
    "unit": {
      "id": "…",
      "kind": "…"
    }
  });
// answer.body is a Journey. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/view/journey",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "unit": {
        "id": "…",
        "kind": "…"
      }
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/view/journey")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&JourneyInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.view.journey` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Journey`. The [tool's page](/reference/tools/si-view-journey) describes it.


---
title: "view: oldest"
description: "a kind, a place, and how many to those units, each with its reason and since when"
section: reference
address: /reference/view/oldest
contract: 0476e35e6e275db5
---

# view: oldest

a kind, a place, and how many to those units, each with its reason and since when

[figure: The caller sends OldestInput to /v1/view/oldest. The platform returns a card whose body is [Oldest].]

<span class="op-method">POST</span><span class="op-path">/v1/view/oldest</span>

The oldest in a place. The call needs the user rung under a token with the read grant, and it is served by the platform.

The route takes [OldestInput](/concepts/oldestinput) and returns a card whose body is [Oldest](/concepts/oldest).



## Request body
The request body is [OldestInput](/concepts/oldestinput).



| field | type | required | note |
|---|---|---|---|
| `kind` | [Kind](/concepts/kind) | yes |  |
| `place` | `text` | yes |  |



## Response
The route returns a card whose body is [Oldest](/concepts/oldest). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the user rung and a token with the read grant. The platform serves this route.

## Example
The example sends the smallest body that OldestInput allows. The build validates it against the schema of OldestInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/view/oldest \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "kind": "…", "place": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.view.oldest({
    "kind": "…",
    "place": "…"
  });
// answer.body is a [Oldest]. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/view/oldest",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "kind": "…",
      "place": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/view/oldest")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&OldestInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.view.oldest` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Oldest`. The [tool's page](/reference/tools/si-view-oldest) describes it.


---
title: "view: pairings"
description: "a scope to each pairing, with the units that lack their pair"
section: reference
address: /reference/view/pairings
contract: 0476e35e6e275db5
---

# view: pairings

a scope to each pairing, with the units that lack their pair

[figure: The caller sends PairingsInput to /v1/view/pairings. The platform returns a card whose body is PairingsAnswer.]

<span class="op-method">POST</span><span class="op-path">/v1/view/pairings</span>

Pairings. The call needs the user rung under a token with the read grant, and it is served by the platform.

The route takes [PairingsInput](/concepts/pairingsinput) and returns a card whose body is [PairingsAnswer](/concepts/pairingsanswer).



## Request body
The request body is [PairingsInput](/concepts/pairingsinput).



| field | type | required | note |
|---|---|---|---|
| `scope` | [Scope](/concepts/scope) | yes |  |



## Response
The route returns a card whose body is [PairingsAnswer](/concepts/pairingsanswer). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the user rung and a token with the read grant. The platform serves this route.

## Example
The example sends the smallest body that PairingsInput allows. The build validates it against the schema of PairingsInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/view/pairings \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "scope": { "level": "shared" } }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.view.pairings({
    "scope": {
      "level": "shared"
    }
  });
// answer.body is a PairingsAnswer. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/view/pairings",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "scope": {
        "level": "shared"
      }
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/view/pairings")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&PairingsInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.view.pairings` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/PairingsAnswer`. The [tool's page](/reference/tools/si-view-pairings) describes it.


---
title: "view: stocks"
description: "a part, a kind or a place, and a scope the caller holds to the six numbers for each"
section: reference
address: /reference/view/stocks
contract: 0476e35e6e275db5
---

# view: stocks

a part, a kind or a place, and a scope the caller holds to the six numbers for each

[figure: The caller sends StocksInput to /v1/view/stocks. The platform returns a card whose body is [Stock].]

<span class="op-method">POST</span><span class="op-path">/v1/view/stocks</span>

Stocks. The call needs the user rung under a token with the read grant, and it is served by the platform.

The route takes [StocksInput](/concepts/stocksinput) and returns a card whose body is [Stock](/concepts/stock).



## Request body
The request body is [StocksInput](/concepts/stocksinput).



| field | type | required | note |
|---|---|---|---|
| `scope` | [Scope](/concepts/scope) | yes |  |
| `kind` | [Kind](/concepts/kind) | no |  |



## Response
The route returns a card whose body is [Stock](/concepts/stock). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the user rung and a token with the read grant. The platform serves this route.

## Example
The example sends the smallest body that StocksInput allows. The build validates it against the schema of StocksInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/view/stocks \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "scope": { "level": "shared" } }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.view.stocks({
    "scope": {
      "level": "shared"
    }
  });
// answer.body is a [Stock]. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/view/stocks",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "scope": {
        "level": "shared"
      }
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/view/stocks")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&StocksInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.view.stocks` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Stock`. The [tool's page](/reference/tools/si-view-stocks) describes it.


---
title: "view: usage"
description: "a tenant, a kind, a provider, a window to quantity and cost by kind, by tenant, by provider and by period, with each provider's reconciliation state"
section: reference
address: /reference/view/usage
contract: 0476e35e6e275db5
---

# view: usage

a tenant, a kind, a provider, a window to quantity and cost by kind, by tenant, by provider and by period, with each provider's reconciliation state

[figure: The caller sends UsageInput to /v1/view/usage. The platform returns a card whose body is UsageReport.]

<span class="op-method">POST</span><span class="op-path">/v1/view/usage</span>

Read usage. The call needs the tenant rung under a token with the read grant, and it is served by the platform.

The route takes [UsageInput](/concepts/usageinput) and returns a card whose body is [UsageReport](/concepts/usagereport).



## Request body
The request body is [UsageInput](/concepts/usageinput).



| field | type | required | note |
|---|---|---|---|
| `tenant` | `id` | no |  |
| `kind` | [KindOfUsage](/concepts/kindofusage) | no |  |
| `provider` | `text` | no |  |
| `window` | [Window](/concepts/window) | yes |  |



## Response
The route returns a card whose body is [UsageReport](/concepts/usagereport). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the tenant rung and a token with the read grant. The platform serves this route.

## Example
The example sends the smallest body that UsageInput allows. The build validates it against the schema of UsageInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/view/usage \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "window": { "from": "…", "to": "…" } }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.view.usage({
    "window": {
      "from": "…",
      "to": "…"
    }
  });
// answer.body is a UsageReport. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/view/usage",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "window": {
        "from": "…",
        "to": "…"
      }
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/view/usage")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&UsageInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.view.usage` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/UsageReport`. The [tool's page](/reference/tools/si-view-usage) describes it.


---
title: "view: waiting"
description: "the caller to notifications, oldest first."
section: reference
address: /reference/view/waiting
contract: 0476e35e6e275db5
---

# view: waiting

the caller to notifications, oldest first.

[figure: The caller sends WaitingInput to /v1/view/waiting. The platform returns a card whose body is [Notification].]

<span class="op-method">POST</span><span class="op-path">/v1/view/waiting</span>

What needs me. Acknowledge; what waits for a person. The call needs the user rung under a token with the read grant, and it is served by the platform.

The route takes [WaitingInput](/concepts/waitinginput) and returns a card whose body is [Notification](/concepts/notification).



## Request body
The request body is [WaitingInput](/concepts/waitinginput).



| field | type | required | note |
|---|---|---|---|
| `acknowledge` | `id` | no |  |



## Response
The route returns a card whose body is [Notification](/concepts/notification). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the user rung and a token with the read grant. The platform serves this route.

## Example
The example sends the smallest body that WaitingInput allows. The build validates it against the schema of WaitingInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/view/waiting \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{}'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.view.waiting({});
// answer.body is a [Notification]. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/view/waiting",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={}).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/view/waiting")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&WaitingInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.view.waiting` takes the same input and returns the same card. The tool only reads data. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Notification`. The [tool's page](/reference/tools/si-view-waiting) describes it.


---
title: "act: act through connector"
description: "the installed connector, the kind, the arguments with their sources to a move, proposed or running by the grant's mode; then the source's own id for what was done"
section: reference
address: /reference/act/act_through_connector
contract: 0476e35e6e275db5
---

# act: act through connector

the installed connector, the kind, the arguments with their sources to a move, proposed or running by the grant's mode; then the source's own id for what was done

[figure: The caller sends ActThroughConnectorInput to /v1/act/act_through_connector. The platform returns a card whose body is Move.]

<span class="op-method">POST</span><span class="op-path">/v1/act/act_through_connector</span><span class="op-note">a task, 202</span>

Run a kind of action. The call needs the brand rung under a token with the act grant, and it is served by the platform.

The route takes [ActThroughConnectorInput](/concepts/actthroughconnectorinput) and returns a card whose body is [Move](/concepts/move).



## Request body
The request body is [ActThroughConnectorInput](/concepts/actthroughconnectorinput).



| field | type | required | note |
|---|---|---|---|
| `installed_connector` | `id` | yes |  |
| `kind_of_action` | `id` | yes |  |
| `arguments` | `{text:json}` | yes |  |
| `argument_sources` | `{text:text}` | yes | the record by id, a definition, a person's own words |



## Response
The route returns a card whose body is [Move](/concepts/move). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true. This route runs as a long step and returns a task with status 202. `POST /v1/work/status` returns the task's progress, and `POST /v1/work/cancel` stops the task.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the brand rung and a token with the act grant. The platform serves this route.

## Example
The example sends the smallest body that ActThroughConnectorInput allows. The build validates it against the schema of ActThroughConnectorInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/act/act_through_connector \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "installed_connector": "…", "kind_of_action": "…", "arguments": {}, "argument_sources": {} }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.act.act_through_connector({
    "installed_connector": "…",
    "kind_of_action": "…",
    "arguments": {},
    "argument_sources": {}
  });
// answer.body is a Move. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/act/act_through_connector",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "installed_connector": "…",
      "kind_of_action": "…",
      "arguments": {},
      "argument_sources": {}
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/act/act_through_connector")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&ActThroughConnectorInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.act.act_through_connector` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Move`. The [tool's page](/reference/tools/si-act-act_through_connector) describes it.


---
title: "act: annotate"
description: "an `Annotation` with the target *an entity* and the entity's id, from the web shell, the desktop shell, the agent or the API; in the side panel the same type travels inside the page's reading to the fact the person stated, a claim or a connection, by its id and kind (`UnitRef`)"
section: reference
address: /reference/act/annotate
contract: 0476e35e6e275db5
---

# act: annotate

an `Annotation` with the target *an entity* and the entity's id, from the web shell, the desktop shell, the agent or the API; in the side panel the same type travels inside the page's reading to the fact the person stated, a claim or a connection, by its id and kind (`UnitRef`)

[figure: The caller sends Annotation to /v1/act/annotate. The platform returns a card whose body is UnitRef.]

<span class="op-method">POST</span><span class="op-path">/v1/act/annotate</span>

Annotate a subject. The call needs the user rung under a token with the act grant, and it is served by the platform.

The route takes [Annotation](/concepts/annotation) and returns a card whose body is [UnitRef](/concepts/unitref).



## Request body
The request body is [Annotation](/concepts/annotation).



| field | type | required | note |
|---|---|---|---|
| `target` | `one of the page \| an item \| a contact \| a region \| an entity` | yes | an entity when the annotation is made on an entity's page or by the agent, with the entity in subject |
| `subject` | `id` | no | the entity the annotation is about when the target is an entity; absent on a page, whose subject the capture supplies |
| `said_in` | `one of the capture panel \| the web shell \| the desktop shell \| the agent \| the API` | no | the face the person said it in; absent means the capture panel |
| `item_field` | `text` | no | the list field the item belongs to |
| `item_key` | `text` | no | the item's own id, or its index |
| `contact` | `text` | no | the contact's namespace and normalised value, joined by a bar |
| `region_selector` | `text` | no | a selector path to the picked element |
| `region_text` | `text` | no | the picked element's visible text |
| `kind` | `one of a tag \| a relation \| a note \| a rival \| a fit \| a membership \| a kind of thing` | yes | a rival marks the subject as competing with one of the tenant's brands; a fit states it fits a kind of buyer; a membership places it in a facet, a vertical, a segment or a community; a kind of thing says what the subject is |
| `register` | `text` | no | the place of the record the unit was found in (kinds of buyer, brands, offerings, facets, verticals, concepts, segments, communities, entities) |
| `value` | `text` | yes | the tag's name, the relation's kind of connection or the person's own words for it, the note, or the kind of entity |
| `entity` | `id` | no | the unit of the record it points at; absent for a thing the record does not hold yet |
| `entity_name` | `text` | no | the unit's name, or the name of a new thing |
| `entity_kind` | `text` | no | the unit's kind, or the kind of entity the person set for a new thing |
| `role` | `text` | no | for a relation: the role the page's subject takes |
| `stated_at` | `time` | yes |  |



## Response
The route returns a card whose body is [UnitRef](/concepts/unitref). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the user rung and a token with the act grant. The platform serves this route.

## Example
The example sends the smallest body that Annotation allows. The build validates it against the schema of Annotation.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/act/annotate \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "target": "the page", "kind": "a tag", "value": "…", "stated_at": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.act.annotate({
    "target": "the page",
    "kind": "a tag",
    "value": "…",
    "stated_at": "…"
  });
// answer.body is a UnitRef. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/act/annotate",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "target": "the page",
      "kind": "a tag",
      "value": "…",
      "stated_at": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/act/annotate")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&Annotation { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.act.annotate` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/UnitRef`. The [tool's page](/reference/tools/si-act-annotate) describes it.


---
title: "act: arm monitor"
description: "the monitor's version, and for arming the preview it was judged by to the monitor's new state"
section: reference
address: /reference/act/arm_monitor
contract: 0476e35e6e275db5
---

# act: arm monitor

the monitor's version, and for arming the preview it was judged by to the monitor's new state

[figure: The caller sends ArmMonitorInput to /v1/act/arm_monitor. The platform returns a card whose body is Monitor.]

<span class="op-method">POST</span><span class="op-path">/v1/act/arm_monitor</span>

Arm, disarm a monitor. The call needs the strategy rung under a token with the act grant, and it is served by the platform.

The route takes [ArmMonitorInput](/concepts/armmonitorinput) and returns a card whose body is [Monitor](/concepts/monitor).



## Request body
The request body is [ArmMonitorInput](/concepts/armmonitorinput).



| field | type | required | note |
|---|---|---|---|
| `monitor` | `id` | yes |  |
| `version` | `count` | yes |  |
| `arm` | `bool` | yes |  |
| `preview` | `id` | no | required to arm |



## Response
The route returns a card whose body is [Monitor](/concepts/monitor). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the strategy rung and a token with the act grant. The platform serves this route.

## Example
The example sends the smallest body that ArmMonitorInput allows. The build validates it against the schema of ArmMonitorInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/act/arm_monitor \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "monitor": "…", "version": 0, "arm": false }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.act.arm_monitor({
    "monitor": "…",
    "version": 0,
    "arm": false
  });
// answer.body is a Monitor. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/act/arm_monitor",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "monitor": "…",
      "version": 0,
      "arm": false
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/act/arm_monitor")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&ArmMonitorInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.act.arm_monitor` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Monitor`. The [tool's page](/reference/tools/si-act-arm_monitor) describes it.


---
title: "act: arm play"
description: "a strategy, the play and its version, the goal it serves, and the share it is armed on with its holdout (a share under one makes the play an experiment) to the armed play with its class proposed from the kind's usual class and the rivals' coverage, and the demand cells it raised"
section: reference
address: /reference/act/arm_play
contract: 0476e35e6e275db5
---

# act: arm play

a strategy, the play and its version, the goal it serves, and the share it is armed on with its holdout (a share under one makes the play an experiment) to the armed play with its class proposed from the kind's usual class and the rivals' coverage, and the demand cells it raised

[figure: The caller sends ArmPlayInput to /v1/act/arm_play. The platform returns a card whose body is ArmPlayAnswer.]

<span class="op-method">POST</span><span class="op-path">/v1/act/arm_play</span>

Arm a play. The call needs the strategy rung under a token with the act grant, and it is served by the platform.

The route takes [ArmPlayInput](/concepts/armplayinput) and returns a card whose body is [ArmPlayAnswer](/concepts/armplayanswer).



## Request body
The request body is [ArmPlayInput](/concepts/armplayinput).



| field | type | required | note |
|---|---|---|---|
| `play` | `id` | yes |  |
| `strategy` | `id` | yes |  |
| `brand` | `id` | yes |  |
| `arm` | `bool` | yes |  |
| `share` | `share` | no | the share of the admitted members the arming admits; absent keeps the play's own |
| `holdout` | `share` | no | the share left alone at random, read as the effect's comparison; absent keeps the play's own |



## Response
The route returns a card whose body is [ArmPlayAnswer](/concepts/armplayanswer). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the strategy rung and a token with the act grant. The platform serves this route.

## Example
The example sends the smallest body that ArmPlayInput allows. The build validates it against the schema of ArmPlayInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/act/arm_play \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "play": "…", "strategy": "…", "brand": "…", "arm": false }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.act.arm_play({
    "play": "…",
    "strategy": "…",
    "brand": "…",
    "arm": false
  });
// answer.body is a ArmPlayAnswer. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/act/arm_play",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "play": "…",
      "strategy": "…",
      "brand": "…",
      "arm": false
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/act/arm_play")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&ArmPlayInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.act.arm_play` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/ArmPlayAnswer`. The [tool's page](/reference/tools/si-act-arm_play) describes it.


---
title: "act: assign"
description: "Assigns one lead to one user by hand, or hands it on to The answer gives the assignment, with the person who made it as its reason"
section: reference
address: /reference/act/assign
contract: 0476e35e6e275db5
---

# act: assign

Assigns one lead to one user by hand, or hands it on to The answer gives the assignment, with the person who made it as its reason

[figure: The caller sends AssignInput to /v1/act/assign. The platform returns a card whose body is LeadAssignment.]

<span class="op-method">POST</span><span class="op-path">/v1/act/assign</span>

Assign by hand. Hand on. The call needs the strategy rung under a token with the act grant, and it is served by the platform.

The route takes [AssignInput](/concepts/assigninput) and returns a card whose body is [LeadAssignment](/concepts/leadassignment).



## Request body
The request body is [AssignInput](/concepts/assigninput).



| field | type | required | note |
|---|---|---|---|
| `lead` | `id` | yes |  |
| `user` | `id` | yes |  |
| `reason` | `text` | yes |  |



## Response
The route returns a card whose body is [LeadAssignment](/concepts/leadassignment). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the strategy rung and a token with the act grant. The platform serves this route.

## Example
The example sends the smallest body that AssignInput allows. The build validates it against the schema of AssignInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/act/assign \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "lead": "…", "user": "…", "reason": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.act.assign({
    "lead": "…",
    "user": "…",
    "reason": "…"
  });
// answer.body is a LeadAssignment. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/act/assign",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "lead": "…",
      "user": "…",
      "reason": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/act/assign")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&AssignInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.act.assign` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/LeadAssignment`. The [tool's page](/reference/tools/si-act-assign) describes it.


---
title: "act: beat"
description: "what runs, and when to the beat"
section: reference
address: /reference/act/beat
contract: 0476e35e6e275db5
---

# act: beat

what runs, and when to the beat

[figure: The caller sends BeatInput to /v1/act/beat. The platform returns a card whose body is Beat.]

<span class="op-method">POST</span><span class="op-path">/v1/act/beat</span>

Write a beat. The call needs the strategy rung under a token with the act grant, and it is served by the platform.

The route takes [BeatInput](/concepts/beatinput) and returns a card whose body is [Beat](/concepts/beat).



## Request body
The request body is [BeatInput](/concepts/beatinput).



| field | type | required | note |
|---|---|---|---|
| `beat` | [Beat](/concepts/beat) | yes |  |



## Response
The route returns a card whose body is [Beat](/concepts/beat). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the strategy rung and a token with the act grant. The platform serves this route.

## Example
The example sends the smallest body that BeatInput allows. The build validates it against the schema of BeatInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/act/beat \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "beat": { "name": "…", "every": "…" } }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.act.beat({
    "beat": {
      "name": "…",
      "every": "…"
    }
  });
// answer.body is a Beat. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/act/beat",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "beat": {
        "name": "…",
        "every": "…"
      }
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/act/beat")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&BeatInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.act.beat` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Beat`. The [tool's page](/reference/tools/si-act-beat) describes it.


---
title: "act: bind buyer"
description: "the kind, an offering or a segment, the weight, the mode to the binding, and the preview of the kind's members"
section: reference
address: /reference/act/bind_buyer
contract: 0476e35e6e275db5
---

# act: bind buyer

the kind, an offering or a segment, the weight, the mode to the binding, and the preview of the kind's members

[figure: The caller sends BindBuyerInput to /v1/act/bind_buyer. The platform returns a card whose body is BindBuyerAnswer.]

<span class="op-method">POST</span><span class="op-path">/v1/act/bind_buyer</span>

Bind a buyer profile. The call needs the brand rung under a token with the act grant, and it is served by the platform.

The route takes [BindBuyerInput](/concepts/bindbuyerinput) and returns a card whose body is [BindBuyerAnswer](/concepts/bindbuyeranswer).



## Request body
The request body is [BindBuyerInput](/concepts/bindbuyerinput).



| field | type | required | note |
|---|---|---|---|
| `kind_of_buyer` | `id` | yes |  |
| `bindings` | [Binding](/concepts/binding) | yes |  |
| `ladder` | `text` | no | the ladder the kind climbs, by its name, where the binding changes it; the ladder must be kept and ready |



## Response
The route returns a card whose body is [BindBuyerAnswer](/concepts/bindbuyeranswer). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the brand rung and a token with the act grant. The platform serves this route.

## Example
The example sends the smallest body that BindBuyerInput allows. The build validates it against the schema of BindBuyerInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/act/bind_buyer \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "kind_of_buyer": "…", "bindings": [] }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.act.bind_buyer({
    "kind_of_buyer": "…",
    "bindings": []
  });
// answer.body is a BindBuyerAnswer. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/act/bind_buyer",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "kind_of_buyer": "…",
      "bindings": []
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/act/bind_buyer")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&BindBuyerInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.act.bind_buyer` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/BindBuyerAnswer`. The [tool's page](/reference/tools/si-act-bind_buyer) describes it.


---
title: "act: board"
description: "the board with its tiles to the board, ready, or not ready with the tile that could not be drawn"
section: reference
address: /reference/act/board
contract: 0476e35e6e275db5
---

# act: board

the board with its tiles to the board, ready, or not ready with the tile that could not be drawn

[figure: The caller sends BoardInput to /v1/act/board. The platform returns a card whose body is Board.]

<span class="op-method">POST</span><span class="op-path">/v1/act/board</span>

Write a board. The call needs the tenant rung under a token with the act grant, and it is served by the platform.

The route takes [BoardInput](/concepts/boardinput) and returns a card whose body is [Board](/concepts/board).



## Request body
The request body is [BoardInput](/concepts/boardinput).



| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `audience` | `text` | yes |  |
| `tiles` | [Tile](/concepts/tile) | yes |  |
| `period` | [Window](/concepts/window) | yes |  |



## Response
The route returns a card whose body is [Board](/concepts/board). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the tenant rung and a token with the act grant. The platform serves this route.

## Example
The example sends the smallest body that BoardInput allows. The build validates it against the schema of BoardInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/act/board \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "name": "…", "audience": "…", "tiles": [], "period": { "from": "…", "to": "…" } }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.act.board({
    "name": "…",
    "audience": "…",
    "tiles": [],
    "period": {
      "from": "…",
      "to": "…"
    }
  });
// answer.body is a Board. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/act/board",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "name": "…",
      "audience": "…",
      "tiles": [],
      "period": {
        "from": "…",
        "to": "…"
      }
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/act/board")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&BoardInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.act.board` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Board`. The [tool's page](/reference/tools/si-act-board) describes it.


---
title: "act: browse step"
description: "a `BrowseStepInput` to the step's result: the accessibility tree, the text, the markdown, a screenshot's hash, or a download set"
section: reference
address: /reference/act/browse_step
contract: 0476e35e6e275db5
---

# act: browse step

a `BrowseStepInput` to the step's result: the accessibility tree, the text, the markdown, a screenshot's hash, or a download set

[figure: The caller sends BrowseStepInput to /v1/act/browse_step. The platform returns a card whose body is BrowsingStep.]

<span class="op-method">POST</span><span class="op-path">/v1/act/browse_step</span><span class="op-note">a task, 202</span>

Drive a browsing step. The call needs the strategy rung under a token with the act grant, and it is served by either, by the size bound.

The route takes [BrowseStepInput](/concepts/browsestepinput) and returns a card whose body is [BrowsingStep](/concepts/browsingstep).



## Request body
The request body is [BrowseStepInput](/concepts/browsestepinput).



| field | type | required | note |
|---|---|---|---|
| `session` | `id` | yes |  |
| `step` | [BrowsingStep](/concepts/browsingstep) | yes |  |



## Response
The route returns a card whose body is [BrowsingStep](/concepts/browsingstep). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true. This route runs as a long step and returns a task with status 202. `POST /v1/work/status` returns the task's progress, and `POST /v1/work/cancel` stops the task.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the strategy rung and a token with the act grant. The platform or the desktop app serves this route.

## Example
The example sends the smallest body that BrowseStepInput allows. The build validates it against the schema of BrowseStepInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/act/browse_step \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "session": "…", "step": { "kind": "navigate", "reach": "reads only", "hop": { "stage": "fetched", "host": "…", "at": "…", "job": "…", "trace_id": "…", "span_id": "…" } } }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.act.browse_step({
    "session": "…",
    "step": {
      "kind": "navigate",
      "reach": "reads only",
      "hop": {
        "stage": "fetched",
        "host": "…",
        "at": "…",
        "job": "…",
        "trace_id": "…",
        "span_id": "…"
      }
    }
  });
// answer.body is a BrowsingStep. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/act/browse_step",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "session": "…",
      "step": {
        "kind": "navigate",
        "reach": "reads only",
        "hop": {
          "stage": "fetched",
          "host": "…",
          "at": "…",
          "job": "…",
          "trace_id": "…",
          "span_id": "…"
        }
      }
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/act/browse_step")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&BrowseStepInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.act.browse_step` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/BrowsingStep`. The [tool's page](/reference/tools/si-act-browse_step) describes it.


---
title: "act: build document"
description: "the document, the two dates, which default to now to the build, then the version, or not ready with every number that is missing"
section: reference
address: /reference/act/build_document
contract: 0476e35e6e275db5
---

# act: build document

the document, the two dates, which default to now to the build, then the version, or not ready with every number that is missing

[figure: The caller sends BuildDocumentInput to /v1/act/build_document. The platform returns a card whose body is Build.]

<span class="op-method">POST</span><span class="op-path">/v1/act/build_document</span><span class="op-note">a task, 202</span>

Build a document. The call needs the brand rung under a token with the act grant, and it is served by the platform.

The route takes [BuildDocumentInput](/concepts/builddocumentinput) and returns a card whose body is [Build](/concepts/build).



## Request body
The request body is [BuildDocumentInput](/concepts/builddocumentinput).



| field | type | required | note |
|---|---|---|---|
| `document` | `id` | yes |  |



## Response
The route returns a card whose body is [Build](/concepts/build). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true. This route runs as a long step and returns a task with status 202. `POST /v1/work/status` returns the task's progress, and `POST /v1/work/cancel` stops the task.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the brand rung and a token with the act grant. The platform serves this route.

## Example
The example sends the smallest body that BuildDocumentInput allows. The build validates it against the schema of BuildDocumentInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/act/build_document \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "document": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.act.build_document({
    "document": "…"
  });
// answer.body is a Build. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/act/build_document",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "document": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/act/build_document")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&BuildDocumentInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.act.build_document` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Build`. The [tool's page](/reference/tools/si-act-build_document) describes it.


---
title: "act: capacity"
description: "Sets how many new leads one user can take in a period to The answer gives the new capacity, with how many the user holds and when it refills"
section: reference
address: /reference/act/capacity
contract: 0476e35e6e275db5
---

# act: capacity

Sets how many new leads one user can take in a period to The answer gives the new capacity, with how many the user holds and when it refills

[figure: The caller sends CapacityInput to /v1/act/capacity. The platform returns a card whose body is Capacity.]

<span class="op-method">POST</span><span class="op-path">/v1/act/capacity</span>

Set capacity. The call needs the brand rung under a token with the act grant, and it is served by the platform.

The route takes [CapacityInput](/concepts/capacityinput) and returns a card whose body is [Capacity](/concepts/capacity).



## Request body
The request body is [CapacityInput](/concepts/capacityinput).



| field | type | required | note |
|---|---|---|---|
| `user` | `id` | yes |  |
| `per_period` | `count` | yes |  |
| `period` | `duration` | yes |  |



## Response
The route returns a card whose body is [Capacity](/concepts/capacity). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the brand rung and a token with the act grant. The platform serves this route.

## Example
The example sends the smallest body that CapacityInput allows. The build validates it against the schema of CapacityInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/act/capacity \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "user": "…", "per_period": 0, "period": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.act.capacity({
    "user": "…",
    "per_period": 0,
    "period": "…"
  });
// answer.body is a Capacity. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/act/capacity",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "user": "…",
      "per_period": 0,
      "period": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/act/capacity")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&CapacityInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.act.capacity` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Capacity`. The [tool's page](/reference/tools/si-act-capacity) describes it.


---
title: "act: capture"
description: "the document, the network events, the address, the person's identity to the capture with its source objects and the cells credited"
section: reference
address: /reference/act/capture
contract: 0476e35e6e275db5
---

# act: capture

the document, the network events, the address, the person's identity to the capture with its source objects and the cells credited

[figure: The caller sends CaptureInput to /v1/act/capture. The platform returns a card whose body is Capture.]

<span class="op-method">POST</span><span class="op-path">/v1/act/capture</span>

Capture a page. The call needs the user rung under a token with the act grant, and it is served by the platform.

The route takes [CaptureInput](/concepts/captureinput) and returns a card whose body is [Capture](/concepts/capture).



## Request body
The request body is [CaptureInput](/concepts/captureinput).



| field | type | required | note |
|---|---|---|---|
| `address` | `text` | yes |  |
| `document` | `text` | yes |  |
| `network_events` | `[json]` | yes |  |
| `identity` | `id` | no |  |
| `scope` | `one of this item \| this thread \| this channel as shown \| this page \| this meeting \| my outbound message` | yes |  |
| `under` | `one of say-so \| rule` | yes |  |
| `rule` | `id` | no |  |
| `extension_version` | `text` | yes |  |
| `artefact_hash` | `hash` | yes |  |
| `selection` | `text` | no |  |



## Response
The route returns a card whose body is [Capture](/concepts/capture). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the user rung and a token with the act grant. The platform serves this route.

## Example
The example sends the smallest body that CaptureInput allows. The build validates it against the schema of CaptureInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/act/capture \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "address": "…", "document": "…", "network_events": [], "scope": "this item", "under": "say-so", "extension_version": "…", "artefact_hash": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.act.capture({
    "address": "…",
    "document": "…",
    "network_events": [],
    "scope": "this item",
    "under": "say-so",
    "extension_version": "…",
    "artefact_hash": "…"
  });
// answer.body is a Capture. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/act/capture",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "address": "…",
      "document": "…",
      "network_events": [],
      "scope": "this item",
      "under": "say-so",
      "extension_version": "…",
      "artefact_hash": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/act/capture")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&CaptureInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.act.capture` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Capture`. The [tool's page](/reference/tools/si-act-capture) describes it.


---
title: "act: capture rule"
description: "the rule to the rule, ready or not ready with the reason"
section: reference
address: /reference/act/capture_rule
contract: 0476e35e6e275db5
---

# act: capture rule

the rule to the rule, ready or not ready with the reason

[figure: The caller sends CaptureRuleInput to /v1/act/capture_rule. The platform returns a card whose body is CaptureRule.]

<span class="op-method">POST</span><span class="op-path">/v1/act/capture_rule</span>

Write a capture rule. The call needs the user rung under a token with the act grant, and it is served by the platform.

The route takes [CaptureRuleInput](/concepts/captureruleinput) and returns a card whose body is [CaptureRule](/concepts/capturerule).



## Request body
The request body is [CaptureRuleInput](/concepts/captureruleinput).



| field | type | required | note |
|---|---|---|---|
| `platform` | `text` | yes |  |
| `mode` | `one of on my say-so \| on my own submit \| ask me on this platform \| every page I open \| never` | yes |  |
| `way` | [AccessMethod](/concepts/accessmethod) | no |  |
| `default_scope` | `one of this item \| this thread \| this channel as shown \| this page \| this meeting \| my outbound message` | yes |  |
| `never_captured` | `[text]` | yes | addresses or kinds |
| `redactions` | [RedactionRule](/concepts/redactionrule) | no | the person's own |
| `browser_grant` | `one of given \| not given \| not needed` | no | the browser's standing host permission for the platform as the extension found it when the rule was written: asked of the person for every page I open, and not needed for the other modes; absent when the rule is written from a surface that is not the browser |



## Response
The route returns a card whose body is [CaptureRule](/concepts/capturerule). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the user rung and a token with the act grant. The platform serves this route.

## Example
The example sends the smallest body that CaptureRuleInput allows. The build validates it against the schema of CaptureRuleInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/act/capture_rule \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "platform": "…", "mode": "on my say-so", "default_scope": "this item", "never_captured": [] }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.act.capture_rule({
    "platform": "…",
    "mode": "on my say-so",
    "default_scope": "this item",
    "never_captured": []
  });
// answer.body is a CaptureRule. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/act/capture_rule",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "platform": "…",
      "mode": "on my say-so",
      "default_scope": "this item",
      "never_captured": []
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/act/capture_rule")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&CaptureRuleInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.act.capture_rule` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/CaptureRule`. The [tool's page](/reference/tools/si-act-capture_rule) describes it.


---
title: "act: change plan"
description: "the plan kind to the change as a proposal, and the provider's own page for payment"
section: reference
address: /reference/act/change_plan
contract: 0476e35e6e275db5
---

# act: change plan

the plan kind to the change as a proposal, and the provider's own page for payment

[figure: The caller sends ChangePlanInput to /v1/act/change_plan. The platform returns a card whose body is PlanChange.]

<span class="op-method">POST</span><span class="op-path">/v1/act/change_plan</span>

Change the plan. The call needs the tenant rung under a token with the admin grant, and it is served by the platform.

The route takes [ChangePlanInput](/concepts/changeplaninput) and returns a card whose body is [PlanChange](/concepts/planchange).



## Request body
The request body is [ChangePlanInput](/concepts/changeplaninput).



| field | type | required | note |
|---|---|---|---|
| `plan_kind` | `one of trial \| paid \| internal` | yes |  |



## Response
The route returns a card whose body is [PlanChange](/concepts/planchange). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the tenant rung and a token with the admin grant. The platform serves this route.

## Example
The example sends the smallest body that ChangePlanInput allows. The build validates it against the schema of ChangePlanInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/act/change_plan \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "plan_kind": "trial" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.act.change_plan({
    "plan_kind": "trial"
  });
// answer.body is a PlanChange. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/act/change_plan",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "plan_kind": "trial"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/act/change_plan")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&ChangePlanInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.act.change_plan` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/PlanChange`. The [tool's page](/reference/tools/si-act-change_plan) describes it.


---
title: "act: correct"
description: "the id of the wrong event, and the right facts to a correcting event"
section: reference
address: /reference/act/correct
contract: 0476e35e6e275db5
---

# act: correct

the id of the wrong event, and the right facts to a correcting event

[figure: The caller sends CorrectInput to /v1/act/correct. The platform returns a card whose body is Event.]

<span class="op-method">POST</span><span class="op-path">/v1/act/correct</span>

Correct an event. The call needs the strategy rung under a token with the act grant, and it is served by the platform.

The route takes [CorrectInput](/concepts/correctinput) and returns a card whose body is [Event](/concepts/event).



## Request body
The request body is [CorrectInput](/concepts/correctinput).



| field | type | required | note |
|---|---|---|---|
| `event` | `id` | yes |  |
| `correction` | [Event](/concepts/event) | yes |  |
| `why` | `text` | yes |  |



## Response
The route returns a card whose body is [Event](/concepts/event). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the strategy rung and a token with the act grant. The platform serves this route.

## Example
The example sends the smallest body that CorrectInput allows. The build validates it against the schema of CorrectInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/act/correct \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "event": "…", "correction": { "flow": "…", "unit": "…", "at": "…", "by": { "kind": "a user", "came_in_through": "a session", "access_scopes": [], "tenant": "…", "grants": [] }, "plane": "tenant plane", "outcome": "…", "run": "…" }, "why": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.act.correct({
    "event": "…",
    "correction": {
      "flow": "…",
      "unit": "…",
      "at": "…",
      "by": {
        "kind": "a user",
        "came_in_through": "a session",
        "access_scopes": [],
        "tenant": "…",
        "grants": []
      },
      "plane": "tenant plane",
      "outcome": "…",
      "run": "…"
    },
    "why": "…"
  });
// answer.body is a Event. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/act/correct",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "event": "…",
      "correction": {
        "flow": "…",
        "unit": "…",
        "at": "…",
        "by": {
          "kind": "a user",
          "came_in_through": "a session",
          "access_scopes": [],
          "tenant": "…",
          "grants": []
        },
        "plane": "tenant plane",
        "outcome": "…",
        "run": "…"
      },
      "why": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/act/correct")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&CorrectInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.act.correct` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Event`. The [tool's page](/reference/tools/si-act-correct) describes it.


---
title: "act: crawl"
description: "a `ScrapeRequest` whose scope names the site's seeds, with sitemap-driven discovery on to the `ScrapeRun`, queued, or the run that already stands for the same template version and scope inside its freshness; every page lands as a capture through the one pipeline, and each page that could not be read is a gap with…"
section: reference
address: /reference/act/crawl
contract: 0476e35e6e275db5
---

# act: crawl

a `ScrapeRequest` whose scope names the site's seeds, with sitemap-driven discovery on to the `ScrapeRun`, queued, or the run that already stands for the same template version and scope inside its freshness; every page lands as a capture through the one pipeline, and each page that could not be read is a gap with…

[figure: The caller sends ScrapeRequest to /v1/act/crawl. The platform returns a card whose body is ScrapeRun.]

<span class="op-method">POST</span><span class="op-path">/v1/act/crawl</span><span class="op-note">a task, 202</span>

Crawl a site. The call needs the brand rung under a token with the act grant, and it is served by the platform.

The route takes [ScrapeRequest](/concepts/scraperequest) and returns a card whose body is [ScrapeRun](/concepts/scraperun).



## Request body
The request body is [ScrapeRequest](/concepts/scraperequest).



| field | type | required | note |
|---|---|---|---|
| `template` | `id` | no | an extraction template; any of its parts may be overridden below |
| `scope` | [CrawlScope](/concepts/crawlscope) | no | required when no template |
| `fields` | [FieldSpec](/concepts/fieldspec) | no | declared selectors |
| `schema` | `json` | no | for the model-assisted reader, every value with its evidence span or refused |
| `source_object` | [SourceObject](/concepts/sourceobject) | yes | declared inline for one scrape, or a registered row |
| `mapping` | [Mapping](/concepts/mapping) | no |  |
| `filter` | [ResourceFilter](/concepts/resourcefilter) | yes |  |
| `as_identity` | `id` | no |  |
| `proxy_policy` | [ProxyPolicy](/concepts/proxypolicy) | no |  |
| `credit_cells` | `[id]` | no |  |
| `asked_by` | `text` | no | who asked for the run, as the caller's kind, or the crawler for an address a walk found; the beat takes what a person or the agent asked before the crawler's own discoveries, oldest first within each |



## Response
The route returns a card whose body is [ScrapeRun](/concepts/scraperun). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true. This route runs as a long step and returns a task with status 202. `POST /v1/work/status` returns the task's progress, and `POST /v1/work/cancel` stops the task.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the brand rung and a token with the act grant. The platform serves this route.

## Example
The example sends the smallest body that ScrapeRequest allows. The build validates it against the schema of ScrapeRequest.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/act/crawl \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "source_object": "…", "filter": { "allow_types": [], "deny_types": [], "allow_patterns": [], "deny_patterns": [], "render": "static" } }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.act.crawl({
    "source_object": "…",
    "filter": {
      "allow_types": [],
      "deny_types": [],
      "allow_patterns": [],
      "deny_patterns": [],
      "render": "static"
    }
  });
// answer.body is a ScrapeRun. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/act/crawl",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "source_object": "…",
      "filter": {
        "allow_types": [],
        "deny_types": [],
        "allow_patterns": [],
        "deny_patterns": [],
        "render": "static"
      }
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/act/crawl")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&ScrapeRequest { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.act.crawl` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/ScrapeRun`. The [tool's page](/reference/tools/si-act-crawl) describes it.


---
title: "act: decide ask"
description: "the ask, by a user who may to the ask, approved or declined"
section: reference
address: /reference/act/decide_ask
contract: 0476e35e6e275db5
---

# act: decide ask

the ask, by a user who may to the ask, approved or declined

[figure: The caller sends DecideAskInput to /v1/act/decide_ask. The platform returns a card whose body is Ask.]

<span class="op-method">POST</span><span class="op-path">/v1/act/decide_ask</span>

Approve or decline an ask. The call needs the brand rung under a token with the act grant, and it is served by the platform.

The route takes [DecideAskInput](/concepts/decideaskinput) and returns a card whose body is [Ask](/concepts/ask).



## Request body
The request body is [DecideAskInput](/concepts/decideaskinput).



| field | type | required | note |
|---|---|---|---|
| `ask` | `id` | yes |  |
| `decision` | `one of approve \| decline` | yes |  |
| `reason` | `text` | no |  |



## Response
The route returns a card whose body is [Ask](/concepts/ask). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the brand rung and a token with the act grant. The platform serves this route.

## Example
The example sends the smallest body that DecideAskInput allows. The build validates it against the schema of DecideAskInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/act/decide_ask \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "ask": "…", "decision": "approve" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.act.decide_ask({
    "ask": "…",
    "decision": "approve"
  });
// answer.body is a Ask. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/act/decide_ask",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "ask": "…",
      "decision": "approve"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/act/decide_ask")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&DecideAskInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.act.decide_ask` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Ask`. The [tool's page](/reference/tools/si-act-decide_ask) describes it.


---
title: "act: decide brand design"
description: "the brand, the value's path, the decision (accepted, declined, changed) and, when changed, the tenant's own value, with the reason to the decision as a fact at brand scope: the brand's memory, read by the merge, so a changed value stands as stated by the tenant until the site changes and a declined one is never…"
section: reference
address: /reference/act/decide_brand_design
contract: 0476e35e6e275db5
---

# act: decide brand design

the brand, the value's path, the decision (accepted, declined, changed) and, when changed, the tenant's own value, with the reason to the decision as a fact at brand scope: the brand's memory, read by the merge, so a changed value stands as stated by the tenant until the site changes and a declined one is never…

[figure: The caller sends DecideBrandDesignInput to /v1/act/decide_brand_design. The platform returns a card whose body is BrandDecision.]

<span class="op-method">POST</span><span class="op-path">/v1/act/decide_brand_design</span>

Record a decision on a brand's design system. The call needs the brand rung under a token with the act grant, and it is served by either, by the size bound.

The route takes [DecideBrandDesignInput](/concepts/decidebranddesigninput) and returns a card whose body is [BrandDecision](/concepts/branddecision).



## Request body
The request body is [DecideBrandDesignInput](/concepts/decidebranddesigninput).



| field | type | required | note |
|---|---|---|---|
| `brand` | `id` | yes |  |
| `path` | `text` | yes |  |
| `decision` | `one of accepted \| declined \| changed` | yes |  |
| `value` | `json` | no | the tenant's own value, when changed |
| `why` | `text` | no |  |



## Response
The route returns a card whose body is [BrandDecision](/concepts/branddecision). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the brand rung and a token with the act grant. The platform or the desktop app serves this route.

## Example
The example sends the smallest body that DecideBrandDesignInput allows. The build validates it against the schema of DecideBrandDesignInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/act/decide_brand_design \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "brand": "…", "path": "…", "decision": "accepted" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.act.decide_brand_design({
    "brand": "…",
    "path": "…",
    "decision": "accepted"
  });
// answer.body is a BrandDecision. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/act/decide_brand_design",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "brand": "…",
      "path": "…",
      "decision": "accepted"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/act/decide_brand_design")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&DecideBrandDesignInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.act.decide_brand_design` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/BrandDecision`. The [tool's page](/reference/tools/si-act-decide_brand_design) describes it.


---
title: "act: decide move"
description: "the move, the caller to the move in its new place, with who moved it"
section: reference
address: /reference/act/decide_move
contract: 0476e35e6e275db5
---

# act: decide move

the move, the caller to the move in its new place, with who moved it

[figure: The caller sends DecideMoveInput to /v1/act/decide_move. The platform returns a card whose body is Move.]

<span class="op-method">POST</span><span class="op-path">/v1/act/decide_move</span>

Accept, decline or stop a move. The call needs the strategy rung under a token with the act grant, and it is served by the platform.

The route takes [DecideMoveInput](/concepts/decidemoveinput) and returns a card whose body is [Move](/concepts/move).



## Request body
The request body is [DecideMoveInput](/concepts/decidemoveinput).



| field | type | required | note |
|---|---|---|---|
| `move` | `id` | yes |  |
| `decision` | `one of accept \| decline \| stop` | yes |  |
| `reason` | `text` | no |  |



## Response
The route returns a card whose body is [Move](/concepts/move). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the strategy rung and a token with the act grant. The platform serves this route.

## Example
The example sends the smallest body that DecideMoveInput allows. The build validates it against the schema of DecideMoveInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/act/decide_move \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "move": "…", "decision": "accept" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.act.decide_move({
    "move": "…",
    "decision": "accept"
  });
// answer.body is a Move. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/act/decide_move",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "move": "…",
      "decision": "accept"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/act/decide_move")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&DecideMoveInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.act.decide_move` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Move`. The [tool's page](/reference/tools/si-act-decide_move) describes it.


---
title: "act: deepen"
description: "an observation, and the depth: fetched in full, or given meaning to a deepening"
section: reference
address: /reference/act/deepen
contract: 0476e35e6e275db5
---

# act: deepen

an observation, and the depth: fetched in full, or given meaning to a deepening

[figure: The caller sends DeepenInput to /v1/act/deepen. The platform returns a card whose body is Deepening.]

<span class="op-method">POST</span><span class="op-path">/v1/act/deepen</span><span class="op-note">a task, 202</span>

Ask for depth. The call needs the strategy rung under a token with the act grant, and it is served by the platform.

The route takes [DeepenInput](/concepts/deepeninput) and returns a card whose body is [Deepening](/concepts/deepening).



## Request body
The request body is [DeepenInput](/concepts/deepeninput).



| field | type | required | note |
|---|---|---|---|
| `observation` | `id` | yes |  |
| `depth` | `one of fetch \| embed \| both` | yes |  |
| `asked_by` | [UnitRef](/concepts/unitref) | yes |  |



## Response
The route returns a card whose body is [Deepening](/concepts/deepening). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true. This route runs as a long step and returns a task with status 202. `POST /v1/work/status` returns the task's progress, and `POST /v1/work/cancel` stops the task.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the strategy rung and a token with the act grant. The platform serves this route.

## Example
The example sends the smallest body that DeepenInput allows. The build validates it against the schema of DeepenInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/act/deepen \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "observation": "…", "depth": "fetch", "asked_by": { "id": "…", "kind": "…" } }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.act.deepen({
    "observation": "…",
    "depth": "fetch",
    "asked_by": {
      "id": "…",
      "kind": "…"
    }
  });
// answer.body is a Deepening. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/act/deepen",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "observation": "…",
      "depth": "fetch",
      "asked_by": {
        "id": "…",
        "kind": "…"
      }
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/act/deepen")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&DeepenInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.act.deepen` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Deepening`. The [tool's page](/reference/tools/si-act-deepen) describes it.


---
title: "act: dry run"
description: "an action to what it would do, and what the inverse would be"
section: reference
address: /reference/act/dry_run
contract: 0476e35e6e275db5
---

# act: dry run

an action to what it would do, and what the inverse would be

[figure: The caller sends DryRunInput to /v1/act/dry_run. The platform returns a card whose body is DryRunAnswer.]

<span class="op-method">POST</span><span class="op-path">/v1/act/dry_run</span>

Dry run an action. The call needs the strategy rung under a token with the ask grant, and it is served by the platform.

The route takes [DryRunInput](/concepts/dryruninput) and returns a card whose body is [DryRunAnswer](/concepts/dryrunanswer).



## Request body
The request body is [DryRunInput](/concepts/dryruninput).



| field | type | required | note |
|---|---|---|---|
| `action` | `id` | yes |  |



## Response
The route returns a card whose body is [DryRunAnswer](/concepts/dryrunanswer). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the strategy rung and a token with the ask grant. The platform serves this route.

## Example
The example sends the smallest body that DryRunInput allows. The build validates it against the schema of DryRunInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/act/dry_run \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "action": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.act.dry_run({
    "action": "…"
  });
// answer.body is a DryRunAnswer. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/act/dry_run",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "action": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/act/dry_run")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&DryRunInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.act.dry_run` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/DryRunAnswer`. The [tool's page](/reference/tools/si-act-dry_run) describes it.


---
title: "act: erase person"
description: "the person to the erasure as work, then its receipt"
section: reference
address: /reference/act/erase_person
contract: 0476e35e6e275db5
---

# act: erase person

the person to the erasure as work, then its receipt

[figure: The caller sends ErasePersonInput to /v1/act/erase_person. The platform returns a card whose body is ErasureReceipt.]

<span class="op-method">POST</span><span class="op-path">/v1/act/erase_person</span><span class="op-note">a task, 202</span>

Erase a person. The call needs the tenant rung under a token with the admin grant, and it is served by the platform.

The route takes [ErasePersonInput](/concepts/erasepersoninput) and returns a card whose body is [ErasureReceipt](/concepts/erasurereceipt).



## Request body
The request body is [ErasePersonInput](/concepts/erasepersoninput).



| field | type | required | note |
|---|---|---|---|
| `person` | `id` | yes |  |
| `verified_by` | `id` | yes |  |



## Response
The route returns a card whose body is [ErasureReceipt](/concepts/erasurereceipt). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true. This route runs as a long step and returns a task with status 202. `POST /v1/work/status` returns the task's progress, and `POST /v1/work/cancel` stops the task.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the tenant rung and a token with the admin grant. The platform serves this route.

## Example
The example sends the smallest body that ErasePersonInput allows. The build validates it against the schema of ErasePersonInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/act/erase_person \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "person": "…", "verified_by": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.act.erase_person({
    "person": "…",
    "verified_by": "…"
  });
// answer.body is a ErasureReceipt. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/act/erase_person",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "person": "…",
      "verified_by": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/act/erase_person")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&ErasePersonInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.act.erase_person` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/ErasureReceipt`. The [tool's page](/reference/tools/si-act-erase_person) describes it.


---
title: "act: export tenant"
description: "nothing to the export as work, then its receipt"
section: reference
address: /reference/act/export_tenant
contract: 0476e35e6e275db5
---

# act: export tenant

nothing to the export as work, then its receipt

[figure: The caller sends Nothing to /v1/act/export_tenant. The platform returns a card whose body is ExportReceipt.]

<span class="op-method">POST</span><span class="op-path">/v1/act/export_tenant</span><span class="op-note">a task, 202</span>

Export a tenant. The call needs the tenant rung under a token with the admin grant, and it is served by the platform.

The route takes an empty body and returns a card whose body is [ExportReceipt](/concepts/exportreceipt).



## Request body
The request body is empty.



## Response
The route returns a card whose body is [ExportReceipt](/concepts/exportreceipt). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true. This route runs as a long step and returns a task with status 202. `POST /v1/work/status` returns the task's progress, and `POST /v1/work/cancel` stops the task.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the tenant rung and a token with the admin grant. The platform serves this route.

## Example
The example sends an empty body.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/act/export_tenant \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{}'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.act.export_tenant({});
// answer.body is a ExportReceipt. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/act/export_tenant",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={}).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/act/export_tenant")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&()).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.act.export_tenant` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/ExportReceipt`. The [tool's page](/reference/tools/si-act-export_tenant) describes it.


---
title: "act: goal"
description: "a strategy, a measure, a target, a window to the goal, naming the measure's version"
section: reference
address: /reference/act/goal
contract: 0476e35e6e275db5
---

# act: goal

a strategy, a measure, a target, a window to the goal, naming the measure's version

[figure: The caller sends GoalInput to /v1/act/goal. The platform returns a card whose body is Goal.]

<span class="op-method">POST</span><span class="op-path">/v1/act/goal</span>

Add a goal. The call needs the strategy rung under a token with the act grant, and it is served by the platform.

The route takes [GoalInput](/concepts/goalinput) and returns a card whose body is [Goal](/concepts/goal).



## Request body
The request body is [GoalInput](/concepts/goalinput).



| field | type | required | note |
|---|---|---|---|
| `goal` | [Goal](/concepts/goal) | yes |  |



## Response
The route returns a card whose body is [Goal](/concepts/goal). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the strategy rung and a token with the act grant. The platform serves this route.

## Example
The example sends the smallest body that GoalInput allows. The build validates it against the schema of GoalInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/act/goal \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "goal": { "strategy": "…", "measure": "…", "measure_version": 0, "target": null, "window": "…" } }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.act.goal({
    "goal": {
      "strategy": "…",
      "measure": "…",
      "measure_version": 0,
      "target": null,
      "window": "…"
    }
  });
// answer.body is a Goal. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/act/goal",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "goal": {
        "strategy": "…",
        "measure": "…",
        "measure_version": 0,
        "target": null,
        "window": "…"
      }
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/act/goal")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&GoalInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.act.goal` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Goal`. The [tool's page](/reference/tools/si-act-goal) describes it.


---
title: "act: grant"
description: "the grant, by a caller who may give it to the grant's new version"
section: reference
address: /reference/act/grant
contract: 0476e35e6e275db5
---

# act: grant

the grant, by a caller who may give it to the grant's new version

[figure: The caller sends GrantInput to /v1/act/grant. The platform returns a card whose body is Grant.]

<span class="op-method">POST</span><span class="op-path">/v1/act/grant</span>

Give, change or withdraw a grant. The call needs the tenant rung under a token with the act grant, and it is served by the platform.

The route takes [GrantInput](/concepts/grantinput) and returns a card whose body is [Grant](/concepts/grant).



## Request body
The request body is [GrantInput](/concepts/grantinput).



| field | type | required | note |
|---|---|---|---|
| `grant` | [Grant](/concepts/grant) | no |  |
| `withdraw` | `id` | no |  |
| `reason` | `text` | yes |  |



## Response
The route returns a card whose body is [Grant](/concepts/grant). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the tenant rung and a token with the act grant. The platform serves this route.

## Example
The example sends the smallest body that GrantInput allows. The build validates it against the schema of GrantInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/act/grant \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "reason": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.act.grant({
    "reason": "…"
  });
// answer.body is a Grant. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/act/grant",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "reason": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/act/grant")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&GrantInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.act.grant` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Grant`. The [tool's page](/reference/tools/si-act-grant) describes it.


---
title: "act: ground"
description: "exactly one of a capture, an entity, a text or an address, and a breadth (`GroundInput`) to the grounding with its hypotheses (`GroundingAnswer`), the channels that ran and the ones not ready with their reason"
section: reference
address: /reference/act/ground
contract: 0476e35e6e275db5
---

# act: ground

exactly one of a capture, an entity, a text or an address, and a breadth (`GroundInput`) to the grounding with its hypotheses (`GroundingAnswer`), the channels that ran and the ones not ready with their reason

[figure: The caller sends GroundInput to /v1/act/ground. The platform returns a card whose body is GroundingAnswer.]

<span class="op-method">POST</span><span class="op-path">/v1/act/ground</span>

Ground a subject at a breadth. The call needs the user rung under a token with the act grant, and it is served by the platform.

The route takes [GroundInput](/concepts/groundinput) and returns a card whose body is [GroundingAnswer](/concepts/groundinganswer).



## Request body
The request body is [GroundInput](/concepts/groundinput).



| field | type | required | note |
|---|---|---|---|
| `capture` | `hash` | no | the artefact's hash |
| `entity` | `id` | no | an entity of the record |
| `text` | `text` | no | a text a person or the agent pasted, cut to 4,000 characters |
| `address` | `text` | no | an address of a page the record may hold as a capture |
| `breadth` | `one of exact \| similar \| related \| broad` | no | the person's default when absent |



## Response
The route returns a card whose body is [GroundingAnswer](/concepts/groundinganswer). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the user rung and a token with the act grant. The platform serves this route.

## Example
The example sends the smallest body that GroundInput allows. The build validates it against the schema of GroundInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/act/ground \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{}'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.act.ground({});
// answer.body is a GroundingAnswer. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/act/ground",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={}).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/act/ground")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&GroundInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.act.ground` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/GroundingAnswer`. The [tool's page](/reference/tools/si-act-ground) describes it.


---
title: "act: hold identity"
description: "the platform, the scopes the rows declare to a browser session for the person; then the credential with its vault entry"
section: reference
address: /reference/act/hold_identity
contract: 0476e35e6e275db5
---

# act: hold identity

the platform, the scopes the rows declare to a browser session for the person; then the credential with its vault entry

[figure: The caller sends HoldIdentityInput to /v1/act/hold_identity. The platform returns a card whose body is SignedInIdentity.]

<span class="op-method">POST</span><span class="op-path">/v1/act/hold_identity</span>

Start a sign-in. The call needs the tenant rung under a token with the act grant, and it is served by the platform.

The route takes [HoldIdentityInput](/concepts/holdidentityinput) and returns a card whose body is [SignedInIdentity](/concepts/signedinidentity).



## Request body
The request body is [HoldIdentityInput](/concepts/holdidentityinput).



| field | type | required | note |
|---|---|---|---|
| `platform` | `text` | yes | the platform's slug, a row of the platform domains |
| `label` | `text` | yes | the person's name for this identity, unique within the tenant and platform |
| `wait_seconds` | `count` | no | how long the platform waits for the sign-in; the parameter row's value when absent |
| `session` | `id` | no | an open browsing session with a live view in which the person signed in; the platform reads the session's cookies as the session given, so nothing leaves any browser; the web version's way that lasts |
| `cookies` | [HeldCookie](/concepts/heldcookie) | no | the session's cookies given as data, read from the person's own browser by the platform's own extension or pasted by the person, for the web version where no window of the platform can open beside the person; when given, no window opens, and the platform keeps the cookies of the platform's domains and probes them |



## Response
The route returns a card whose body is [SignedInIdentity](/concepts/signedinidentity). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the tenant rung and a token with the act grant. The platform serves this route.

## Example
The example sends the smallest body that HoldIdentityInput allows. The build validates it against the schema of HoldIdentityInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/act/hold_identity \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "platform": "…", "label": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.act.hold_identity({
    "platform": "…",
    "label": "…"
  });
// answer.body is a SignedInIdentity. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/act/hold_identity",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "platform": "…",
      "label": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/act/hold_identity")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&HoldIdentityInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.act.hold_identity` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/SignedInIdentity`. The [tool's page](/reference/tools/si-act-hold_identity) describes it.


---
title: "act: install connector"
description: "the connector, the ways chosen, and the identity for each to an installed connector, ready or not ready with its reason"
section: reference
address: /reference/act/install_connector
contract: 0476e35e6e275db5
---

# act: install connector

the connector, the ways chosen, and the identity for each to an installed connector, ready or not ready with its reason

[figure: The caller sends InstallConnectorInput to /v1/act/install_connector. The platform returns a card whose body is InstalledConnector.]

<span class="op-method">POST</span><span class="op-path">/v1/act/install_connector</span>

Install a connector. The call needs the brand rung under a token with the act grant, and it is served by the platform.

The route takes [InstallConnectorInput](/concepts/installconnectorinput) and returns a card whose body is [InstalledConnector](/concepts/installedconnector).



## Request body
The request body is [InstallConnectorInput](/concepts/installconnectorinput).



| field | type | required | note |
|---|---|---|---|
| `installed` | [InstalledConnector](/concepts/installedconnector) | yes |  |



## Response
The route returns a card whose body is [InstalledConnector](/concepts/installedconnector). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the brand rung and a token with the act grant. The platform serves this route.

## Example
The example sends the smallest body that InstallConnectorInput allows. The build validates it against the schema of InstallConnectorInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/act/install_connector \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "installed": { "connector": "…", "ways": [], "identity": "…", "settings": null, "state": { "ready": false, "since": "…" } } }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.act.install_connector({
    "installed": {
      "connector": "…",
      "ways": [],
      "identity": "…",
      "settings": null,
      "state": {
        "ready": false,
        "since": "…"
      }
    }
  });
// answer.body is a InstalledConnector. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/act/install_connector",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "installed": {
        "connector": "…",
        "ways": [],
        "identity": "…",
        "settings": null,
        "state": {
          "ready": false,
          "since": "…"
        }
      }
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/act/install_connector")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&InstallConnectorInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.act.install_connector` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/InstalledConnector`. The [tool's page](/reference/tools/si-act-install_connector) describes it.


---
title: "act: install pack"
description: "a brand, the pack and its version to the copies made, each naming its origin"
section: reference
address: /reference/act/install_pack
contract: 0476e35e6e275db5
---

# act: install pack

a brand, the pack and its version to the copies made, each naming its origin

[figure: The caller sends InstallPackInput to /v1/act/install_pack. The platform returns a card whose body is InstallPackAnswer.]

<span class="op-method">POST</span><span class="op-path">/v1/act/install_pack</span>

Install a vertical pack. The call needs the brand rung under a token with the act grant, and it is served by the platform.

The route takes [InstallPackInput](/concepts/installpackinput) and returns a card whose body is [InstallPackAnswer](/concepts/installpackanswer).



## Request body
The request body is [InstallPackInput](/concepts/installpackinput).



| field | type | required | note |
|---|---|---|---|
| `brand` | `id` | yes |  |
| `template` | `id` | yes |  |
| `version` | `count` | yes |  |



## Response
The route returns a card whose body is [InstallPackAnswer](/concepts/installpackanswer). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the brand rung and a token with the act grant. The platform serves this route.

## Example
The example sends the smallest body that InstallPackInput allows. The build validates it against the schema of InstallPackInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/act/install_pack \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "brand": "…", "template": "…", "version": 0 }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.act.install_pack({
    "brand": "…",
    "template": "…",
    "version": 0
  });
// answer.body is a InstallPackAnswer. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/act/install_pack",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "brand": "…",
      "template": "…",
      "version": 0
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/act/install_pack")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&InstallPackInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.act.install_pack` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/InstallPackAnswer`. The [tool's page](/reference/tools/si-act-install_pack) describes it.


---
title: "act: invite"
description: "an address and a role to the invitation, open, with its expiry"
section: reference
address: /reference/act/invite
contract: 0476e35e6e275db5
---

# act: invite

an address and a role to the invitation, open, with its expiry

[figure: The caller sends InviteInput to /v1/act/invite. The platform returns a card whose body is Invitation.]

<span class="op-method">POST</span><span class="op-path">/v1/act/invite</span>

Invite a person. The call needs the tenant rung under a token with the admin grant, and it is served by the platform.

The route takes [InviteInput](/concepts/inviteinput) and returns a card whose body is [Invitation](/concepts/invitation).



## Request body
The request body is [InviteInput](/concepts/inviteinput).



| field | type | required | note |
|---|---|---|---|
| `address` | `text` | yes |  |
| `role` | `text` | yes |  |
| `held_on` | [Scope](/concepts/scope) | no | the tenant, brand or strategy the role is held on; absent means the whole tenant, which a guest may not hold (a guest holds roles only on the brands they were invited to) |



## Response
The route returns a card whose body is [Invitation](/concepts/invitation). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the tenant rung and a token with the admin grant. The platform serves this route.

## Example
The example sends the smallest body that InviteInput allows. The build validates it against the schema of InviteInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/act/invite \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "address": "…", "role": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.act.invite({
    "address": "…",
    "role": "…"
  });
// answer.body is a Invitation. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/act/invite",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "address": "…",
      "role": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/act/invite")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&InviteInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.act.invite` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Invitation`. The [tool's page](/reference/tools/si-act-invite) describes it.


---
title: "act: keep basket"
description: "its name, its scope and its proxies by version to the basket with its version, not ready while any proxy is"
section: reference
address: /reference/act/keep_basket
contract: 0476e35e6e275db5
---

# act: keep basket

its name, its scope and its proxies by version to the basket with its version, not ready while any proxy is

[figure: The caller sends KeepBasketInput to /v1/act/keep_basket. The platform returns a card whose body is ProxyBasket.]

<span class="op-method">POST</span><span class="op-path">/v1/act/keep_basket</span>

Keep a basket of proxies. The call needs the strategy rung under a token with the act grant, and it is served by either, by the size bound.

The route takes [KeepBasketInput](/concepts/keepbasketinput) and returns a card whose body is [ProxyBasket](/concepts/proxybasket).



## Request body
The request body is [KeepBasketInput](/concepts/keepbasketinput).



| field | type | required | note |
|---|---|---|---|
| `basket` | [ProxyBasket](/concepts/proxybasket) | yes |  |



## Response
The route returns a card whose body is [ProxyBasket](/concepts/proxybasket). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the strategy rung and a token with the act grant. The platform or the desktop app serves this route.

## Example
The example sends the smallest body that KeepBasketInput allows. The build validates it against the schema of KeepBasketInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/act/keep_basket \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "basket": { "name": "…", "proxies": [], "scope": { "level": "shared" }, "version": 0 } }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.act.keep_basket({
    "basket": {
      "name": "…",
      "proxies": [],
      "scope": {
        "level": "shared"
      },
      "version": 0
    }
  });
// answer.body is a ProxyBasket. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/act/keep_basket",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "basket": {
        "name": "…",
        "proxies": [],
        "scope": {
          "level": "shared"
        },
        "version": 0
      }
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/act/keep_basket")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&KeepBasketInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.act.keep_basket` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/ProxyBasket`. The [tool's page](/reference/tools/si-act-keep_basket) describes it.


---
title: "act: keep buyer"
description: "the whole profile as it should stand next, with its predicate's tree given in full, its bindings and its ladder to the profile as its next version, ready, or not ready with the compiler's reason; the predicate kept by its hash"
section: reference
address: /reference/act/keep_buyer
contract: 0476e35e6e275db5
---

# act: keep buyer

the whole profile as it should stand next, with its predicate's tree given in full, its bindings and its ladder to the profile as its next version, ready, or not ready with the compiler's reason; the predicate kept by its hash

[figure: The caller sends KeepBuyerInput to /v1/act/keep_buyer. The platform returns a card whose body is KindOfBuyer.]

<span class="op-method">POST</span><span class="op-path">/v1/act/keep_buyer</span>

Keep a buyer profile. The call needs the brand rung under a token with the act grant, and it is served by the platform.

The route takes [KeepBuyerInput](/concepts/keepbuyerinput) and returns a card whose body is [KindOfBuyer](/concepts/kindofbuyer).



## Request body
The request body is [KeepBuyerInput](/concepts/keepbuyerinput).



| field | type | required | note |
|---|---|---|---|
| `kind_of_buyer` | [KindOfBuyer](/concepts/kindofbuyer) | yes | the whole profile, with the predicate's tree given in full |



## Response
The route returns a card whose body is [KindOfBuyer](/concepts/kindofbuyer). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the brand rung and a token with the act grant. The platform serves this route.

## Example
The example sends the smallest body that KeepBuyerInput allows. The build validates it against the schema of KeepBuyerInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/act/keep_buyer \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "kind_of_buyer": { "name": "…", "sentence": "…", "predicate": { "tree": { "form": "group" }, "population": "…", "tree_hash": "…", "register_hash": "…", "compiler_version": "…", "comparator_versions": {} }, "bindings": [], "ladder": "…" } }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.act.keep_buyer({
    "kind_of_buyer": {
      "name": "…",
      "sentence": "…",
      "predicate": {
        "tree": {
          "form": "group"
        },
        "population": "…",
        "tree_hash": "…",
        "register_hash": "…",
        "compiler_version": "…",
        "comparator_versions": {}
      },
      "bindings": [],
      "ladder": "…"
    }
  });
// answer.body is a KindOfBuyer. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/act/keep_buyer",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "kind_of_buyer": {
        "name": "…",
        "sentence": "…",
        "predicate": {
          "tree": {
            "form": "group"
          },
          "population": "…",
          "tree_hash": "…",
          "register_hash": "…",
          "compiler_version": "…",
          "comparator_versions": {}
        },
        "bindings": [],
        "ladder": "…"
      }
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/act/keep_buyer")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&KeepBuyerInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.act.keep_buyer` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/KindOfBuyer`. The [tool's page](/reference/tools/si-act-keep_buyer) describes it.


---
title: "act: keep ladder"
description: "its ordered rungs, each a predicate over the population, and the rung that qualifies; the rungs' predicates in full where they are not yet kept to the ladder with its version, not ready while a rung's predicate is not kept or does not compile"
section: reference
address: /reference/act/keep_ladder
contract: 0476e35e6e275db5
---

# act: keep ladder

its ordered rungs, each a predicate over the population, and the rung that qualifies; the rungs' predicates in full where they are not yet kept to the ladder with its version, not ready while a rung's predicate is not kept or does not compile

[figure: The caller sends KeepLadderInput to /v1/act/keep_ladder. The platform returns a card whose body is Ladder.]

<span class="op-method">POST</span><span class="op-path">/v1/act/keep_ladder</span>

Keep a ladder. The call needs the brand rung under a token with the act grant, and it is served by either, by the size bound.

The route takes [KeepLadderInput](/concepts/keepladderinput) and returns a card whose body is [Ladder](/concepts/ladder).



## Request body
The request body is [KeepLadderInput](/concepts/keepladderinput).



| field | type | required | note |
|---|---|---|---|
| `ladder` | [Ladder](/concepts/ladder) | yes | the rungs carry their predicates by hash; a rung whose predicate is given in full under `predicates` is kept first |
| `predicates` | [Predicate](/concepts/predicate) | no | the rungs' predicates in full, kept by their hashes before the ladder |



## Response
The route returns a card whose body is [Ladder](/concepts/ladder). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the brand rung and a token with the act grant. The platform or the desktop app serves this route.

## Example
The example sends the smallest body that KeepLadderInput allows. The build validates it against the schema of KeepLadderInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/act/keep_ladder \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "ladder": { "name": "…", "rungs": [], "qualifying_rung": "…" } }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.act.keep_ladder({
    "ladder": {
      "name": "…",
      "rungs": [],
      "qualifying_rung": "…"
    }
  });
// answer.body is a Ladder. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/act/keep_ladder",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "ladder": {
        "name": "…",
        "rungs": [],
        "qualifying_rung": "…"
      }
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/act/keep_ladder")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&KeepLadderInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.act.keep_ladder` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Ladder`. The [tool's page](/reference/tools/si-act-keep_ladder) describes it.


---
title: "act: keep monitor"
description: "its name, its predicate, the place it runs at, the kind of signal it makes, the strategy where one is chosen, and for a platform monitor the vertical to the monitor with its version, not armed; not ready while its predicate does not compile at its place, with the reasons from compile"
section: reference
address: /reference/act/keep_monitor
contract: 0476e35e6e275db5
---

# act: keep monitor

its name, its predicate, the place it runs at, the kind of signal it makes, the strategy where one is chosen, and for a platform monitor the vertical to the monitor with its version, not armed; not ready while its predicate does not compile at its place, with the reasons from compile

[figure: The caller sends KeepMonitorInput to /v1/act/keep_monitor. The platform returns a card whose body is Monitor.]

<span class="op-method">POST</span><span class="op-path">/v1/act/keep_monitor</span>

Keep a monitor. The call needs the strategy rung under a token with the act grant, and it is served by either, by the size bound.

The route takes [KeepMonitorInput](/concepts/keepmonitorinput) and returns a card whose body is [Monitor](/concepts/monitor).



## Request body
The request body is [KeepMonitorInput](/concepts/keepmonitorinput).



| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `predicate` | [Predicate](/concepts/predicate) | yes | the tree, compiled at the place |
| `place` | [PlaceARunsAt](/concepts/placearunsat) | yes |  |
| `kind_of_signal` | [KindOfSignal](/concepts/kindofsignal) | yes |  |
| `strategy` | `id` | no | the brand's standing strategy unless one is chosen |
| `vertical` | `text` | no | for a platform monitor |



## Response
The route returns a card whose body is [Monitor](/concepts/monitor). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the strategy rung and a token with the act grant. The platform or the desktop app serves this route.

## Example
The example sends the smallest body that KeepMonitorInput allows. The build validates it against the schema of KeepMonitorInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/act/keep_monitor \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "name": "…", "predicate": { "tree": { "form": "group" }, "population": "…", "tree_hash": "…", "register_hash": "…", "compiler_version": "…", "comparator_versions": {} }, "place": "…", "kind_of_signal": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.act.keep_monitor({
    "name": "…",
    "predicate": {
      "tree": {
        "form": "group"
      },
      "population": "…",
      "tree_hash": "…",
      "register_hash": "…",
      "compiler_version": "…",
      "comparator_versions": {}
    },
    "place": "…",
    "kind_of_signal": "…"
  });
// answer.body is a Monitor. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/act/keep_monitor",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "name": "…",
      "predicate": {
        "tree": {
          "form": "group"
        },
        "population": "…",
        "tree_hash": "…",
        "register_hash": "…",
        "compiler_version": "…",
        "comparator_versions": {}
      },
      "place": "…",
      "kind_of_signal": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/act/keep_monitor")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&KeepMonitorInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.act.keep_monitor` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Monitor`. The [tool's page](/reference/tools/si-act-keep_monitor) describes it.


---
title: "act: keep play"
description: "a play for a brand, written once by the platform as an original or by the tenant: its goal, its condition as a predicate over its population, its class, its tactic, the move it proposes, its measure, its window, its forecast rule, its comparison, when it stops, and its graph of moves as edges (`KeepPlayInput`); the…"
section: reference
address: /reference/act/keep_play
contract: 0476e35e6e275db5
---

# act: keep play

a play for a brand, written once by the platform as an original or by the tenant: its goal, its condition as a predicate over its population, its class, its tactic, the move it proposes, its measure, its window, its forecast rule, its comparison, when it stops, and its graph of moves as edges (`KeepPlayInput`); the…

[figure: The caller sends KeepPlayInput to /v1/act/keep_play. The platform returns a card whose body is Play.]

<span class="op-method">POST</span><span class="op-path">/v1/act/keep_play</span>

Keep a play. The call needs the brand rung under a token with the act grant, and it is served by the platform.

The route takes [KeepPlayInput](/concepts/keepplayinput) and returns a card whose body is [Play](/concepts/play).



## Request body
The request body is [KeepPlayInput](/concepts/keepplayinput).



| field | type | required | note |
|---|---|---|---|
| `play` | [Play](/concepts/play) | yes | its condition and its edges carry their predicates by hash; a predicate given in full under `predicates` is kept first |
| `predicates` | [Predicate](/concepts/predicate) | no | the condition's and the edges' predicates in full, kept by their hashes before the play |



## Response
The route returns a card whose body is [Play](/concepts/play). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the brand rung and a token with the act grant. The platform serves this route.

## Example
The example sends the smallest body that KeepPlayInput allows. The build validates it against the schema of KeepPlayInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/act/keep_play \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "play": { "name": "…", "brand": "…", "goal": "…", "condition": { "tree": { "form": "group" }, "population": "…", "tree_hash": "…", "register_hash": "…", "compiler_version": "…", "comparator_versions": {} }, "class": "…", "tactic": "…", "proposes": "…", "measure": "…", "window": "…", "forecast_rule": "…", "comparison": "…", "stop": "…", "armed": false, "kind_of_move": "…", "graph": [], "share": 0, "holdout": 0, "trigger": "a match" } }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.act.keep_play({
    "play": {
      "name": "…",
      "brand": "…",
      "goal": "…",
      "condition": {
        "tree": {
          "form": "group"
        },
        "population": "…",
        "tree_hash": "…",
        "register_hash": "…",
        "compiler_version": "…",
        "comparator_versions": {}
      },
      "class": "…",
      "tactic": "…",
      "proposes": "…",
      "measure": "…",
      "window": "…",
      "forecast_rule": "…",
      "comparison": "…",
      "stop": "…",
      "armed": false,
      "kind_of_move": "…",
      "graph": [],
      "share": 0,
      "holdout": 0,
      "trigger": "a match"
    }
  });
// answer.body is a Play. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/act/keep_play",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "play": {
        "name": "…",
        "brand": "…",
        "goal": "…",
        "condition": {
          "tree": {
            "form": "group"
          },
          "population": "…",
          "tree_hash": "…",
          "register_hash": "…",
          "compiler_version": "…",
          "comparator_versions": {}
        },
        "class": "…",
        "tactic": "…",
        "proposes": "…",
        "measure": "…",
        "window": "…",
        "forecast_rule": "…",
        "comparison": "…",
        "stop": "…",
        "armed": false,
        "kind_of_move": "…",
        "graph": [],
        "share": 0,
        "holdout": 0,
        "trigger": "a match"
      }
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/act/keep_play")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&KeepPlayInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.act.keep_play` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Play`. The [tool's page](/reference/tools/si-act-keep_play) describes it.


---
title: "act: keep proxy"
description: "a proxy: its name, the facet kind it stands for, its scope, its rule as a predicate, its strength, its named control, its failure mode, and whether it is aggregate-only to the proxy with its version by hash, not ready until its controls have run and its calibration is read"
section: reference
address: /reference/act/keep_proxy
contract: 0476e35e6e275db5
---

# act: keep proxy

a proxy: its name, the facet kind it stands for, its scope, its rule as a predicate, its strength, its named control, its failure mode, and whether it is aggregate-only to the proxy with its version by hash, not ready until its controls have run and its calibration is read

[figure: The caller sends KeepProxyInput to /v1/act/keep_proxy. The platform returns a card whose body is Proxy.]

<span class="op-method">POST</span><span class="op-path">/v1/act/keep_proxy</span>

Keep a proxy. The call needs the strategy rung under a token with the act grant, and it is served by either, by the size bound.

The route takes [KeepProxyInput](/concepts/keepproxyinput) and returns a card whose body is [Proxy](/concepts/proxy).



## Request body
The request body is [KeepProxyInput](/concepts/keepproxyinput).



| field | type | required | note |
|---|---|---|---|
| `proxy` | [Proxy](/concepts/proxy) | yes |  |



## Response
The route returns a card whose body is [Proxy](/concepts/proxy). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the strategy rung and a token with the act grant. The platform or the desktop app serves this route.

## Example
The example sends the smallest body that KeepProxyInput allows. The build validates it against the schema of KeepProxyInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/act/keep_proxy \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "proxy": { "name": "…", "facet_kind": "…", "observable": "…", "stands_for": "…", "engine": "membership", "rule": { "tree": { "form": "group" }, "population": "…", "tree_hash": "…", "register_hash": "…", "compiler_version": "…", "comparator_versions": {} }, "scope": { "level": "shared" }, "verdict": "measured", "universal_controls": [], "named_controls": [], "aggregate_only": false, "rights": { "keep": false, "show_to_a_tenant": false, "quote": false, "publish_again": false, "train_a_model_on": false, "put_in_a_prompt": false, "let_leave_the_platform": false, "tier": "1", "may_reach_a_lead": false, "may_reach_outreach": false }, "state": { "ready": false, "since": "…" } } }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.act.keep_proxy({
    "proxy": {
      "name": "…",
      "facet_kind": "…",
      "observable": "…",
      "stands_for": "…",
      "engine": "membership",
      "rule": {
        "tree": {
          "form": "group"
        },
        "population": "…",
        "tree_hash": "…",
        "register_hash": "…",
        "compiler_version": "…",
        "comparator_versions": {}
      },
      "scope": {
        "level": "shared"
      },
      "verdict": "measured",
      "universal_controls": [],
      "named_controls": [],
      "aggregate_only": false,
      "rights": {
        "keep": false,
        "show_to_a_tenant": false,
        "quote": false,
        "publish_again": false,
        "train_a_model_on": false,
        "put_in_a_prompt": false,
        "let_leave_the_platform": false,
        "tier": "1",
        "may_reach_a_lead": false,
        "may_reach_outreach": false
      },
      "state": {
        "ready": false,
        "since": "…"
      }
    }
  });
// answer.body is a Proxy. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/act/keep_proxy",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "proxy": {
        "name": "…",
        "facet_kind": "…",
        "observable": "…",
        "stands_for": "…",
        "engine": "membership",
        "rule": {
          "tree": {
            "form": "group"
          },
          "population": "…",
          "tree_hash": "…",
          "register_hash": "…",
          "compiler_version": "…",
          "comparator_versions": {}
        },
        "scope": {
          "level": "shared"
        },
        "verdict": "measured",
        "universal_controls": [],
        "named_controls": [],
        "aggregate_only": false,
        "rights": {
          "keep": false,
          "show_to_a_tenant": false,
          "quote": false,
          "publish_again": false,
          "train_a_model_on": false,
          "put_in_a_prompt": false,
          "let_leave_the_platform": false,
          "tier": "1",
          "may_reach_a_lead": false,
          "may_reach_outreach": false
        },
        "state": {
          "ready": false,
          "since": "…"
        }
      }
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/act/keep_proxy")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&KeepProxyInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.act.keep_proxy` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Proxy`. The [tool's page](/reference/tools/si-act-keep_proxy) describes it.


---
title: "act: make brand design system"
description: "the brand, and the site when it is not the brand row's own to the brand's design system as the next version of its name: every colour, face, size, step, radius, shadow and the logo, each measured, inferred by a named rule or never measured, with the artefacts it was read from and the gaps; and the same values in…"
section: reference
address: /reference/act/make_brand_design_system
contract: 0476e35e6e275db5
---

# act: make brand design system

the brand, and the site when it is not the brand row's own to the brand's design system as the next version of its name: every colour, face, size, step, radius, shadow and the logo, each measured, inferred by a named rule or never measured, with the artefacts it was read from and the gaps; and the same values in…

[figure: The caller sends MakeBrandDesignSystemInput to /v1/act/make_brand_design_system. The platform returns a card whose body is BrandDesignSystem.]

<span class="op-method">POST</span><span class="op-path">/v1/act/make_brand_design_system</span>

Make a brand's design system from its pages. The call needs the brand rung under a token with the act grant, and it is served by the platform.

The route takes [MakeBrandDesignSystemInput](/concepts/makebranddesignsysteminput) and returns a card whose body is [BrandDesignSystem](/concepts/branddesignsystem).



## Request body
The request body is [MakeBrandDesignSystemInput](/concepts/makebranddesignsysteminput).



| field | type | required | note |
|---|---|---|---|
| `brand` | `id` | yes |  |
| `website` | `address` | no | defaults to the brand row's own |



## Response
The route returns a card whose body is [BrandDesignSystem](/concepts/branddesignsystem). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the brand rung and a token with the act grant. The platform serves this route.

## Example
The example sends the smallest body that MakeBrandDesignSystemInput allows. The build validates it against the schema of MakeBrandDesignSystemInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/act/make_brand_design_system \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "brand": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.act.make_brand_design_system({
    "brand": "…"
  });
// answer.body is a BrandDesignSystem. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/act/make_brand_design_system",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "brand": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/act/make_brand_design_system")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&MakeBrandDesignSystemInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.act.make_brand_design_system` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/BrandDesignSystem`. The [tool's page](/reference/tools/si-act-make_brand_design_system) describes it.


---
title: "act: make market twin"
description: "Makes one market twin from a vertical, a segment, a brand, a template and the way of going to market it serves to The answer gives the twin, ready or not ready with the stock the record cannot read named"
section: reference
address: /reference/act/make_market_twin
contract: 0476e35e6e275db5
---

# act: make market twin

Makes one market twin from a vertical, a segment, a brand, a template and the way of going to market it serves to The answer gives the twin, ready or not ready with the stock the record cannot read named

[figure: The caller sends MakeMarketTwinInput to /v1/act/make_market_twin. The platform returns a card whose body is MarketTwin.]

<span class="op-method">POST</span><span class="op-path">/v1/act/make_market_twin</span>

Make the twin of a market. The call needs the brand rung under a token with the act grant, and it is served by the platform.

The route takes [MakeMarketTwinInput](/concepts/makemarkettwininput) and returns a card whose body is [MarketTwin](/concepts/markettwin).



## Request body
The request body is [MakeMarketTwinInput](/concepts/makemarkettwininput).



| field | type | required | note |
|---|---|---|---|
| `vertical` | `id` | yes |  |
| `segment` | `id` | no |  |
| `brand` | `id` | yes |  |
| `template` | [SystemsModelTemplate](/concepts/systemsmodeltemplate) | yes |  |
| `way` | [WayOfGoingToMarket](/concepts/wayofgoingtomarket) | no |  |
| `as_of` | `time` | no | today when absent |



## Response
The route returns a card whose body is [MarketTwin](/concepts/markettwin). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the brand rung and a token with the act grant. The platform serves this route.

## Example
The example sends the smallest body that MakeMarketTwinInput allows. The build validates it against the schema of MakeMarketTwinInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/act/make_market_twin \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "vertical": "…", "brand": "…", "template": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.act.make_market_twin({
    "vertical": "…",
    "brand": "…",
    "template": "…"
  });
// answer.body is a MarketTwin. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/act/make_market_twin",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "vertical": "…",
      "brand": "…",
      "template": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/act/make_market_twin")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&MakeMarketTwinInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.act.make_market_twin` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/MarketTwin`. The [tool's page](/reference/tools/si-act-make_market_twin) describes it.


---
title: "act: map brand"
description: "a web address, and the brand scope to hold the map to the map as it stands, with every part measured or never measured, and the demand raised"
section: reference
address: /reference/act/map_brand
contract: 0476e35e6e275db5
---

# act: map brand

a web address, and the brand scope to hold the map to the map as it stands, with every part measured or never measured, and the demand raised

[figure: The caller sends MapBrandInput to /v1/act/map_brand. The platform returns a card whose body is Map.]

<span class="op-method">POST</span><span class="op-path">/v1/act/map_brand</span><span class="op-note">a task, 202</span>

Map a brand from a website. The call needs the brand rung under a token with the act grant, and it is served by the platform.

The route takes [MapBrandInput](/concepts/mapbrandinput) and returns a card whose body is [Map](/concepts/map).



## Request body
The request body is [MapBrandInput](/concepts/mapbrandinput).



| field | type | required | note |
|---|---|---|---|
| `website` | `address` | yes |  |
| `name` | `text` | no |  |
| `tenant` | `id` | yes |  |



## Response
The route returns a card whose body is [Map](/concepts/map). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true. This route runs as a long step and returns a task with status 202. `POST /v1/work/status` returns the task's progress, and `POST /v1/work/cancel` stops the task.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the brand rung and a token with the act grant. The platform serves this route.

## Example
The example sends the smallest body that MapBrandInput allows. The build validates it against the schema of MapBrandInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/act/map_brand \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "website": "…", "tenant": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.act.map_brand({
    "website": "…",
    "tenant": "…"
  });
// answer.body is a Map. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/act/map_brand",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "website": "…",
      "tenant": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/act/map_brand")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&MapBrandInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.act.map_brand` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Map`. The [tool's page](/reference/tools/si-act-map_brand) describes it.


---
title: "act: mark lead"
description: "Marks a condition on one lead, with a reason where the condition asks for one to The answer gives the lead's new outcome"
section: reference
address: /reference/act/mark_lead
contract: 0476e35e6e275db5
---

# act: mark lead

Marks a condition on one lead, with a reason where the condition asks for one to The answer gives the lead's new outcome

[figure: The caller sends MarkLeadInput to /v1/act/mark_lead. The platform returns a card whose body is Outcome.]

<span class="op-method">POST</span><span class="op-path">/v1/act/mark_lead</span>

Mark a condition. The call needs the strategy rung under a token with the act grant, and it is served by the platform.

The route takes [MarkLeadInput](/concepts/markleadinput) and returns a card whose body is [Outcome](/concepts/outcome).



## Request body
The request body is [MarkLeadInput](/concepts/markleadinput).



| field | type | required | note |
|---|---|---|---|
| `lead` | `id` | yes |  |
| `condition` | [LeadCondition](/concepts/leadcondition) | yes |  |
| `reason` | `text` | no |  |



## Response
The route returns a card whose body is [Outcome](/concepts/outcome). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the strategy rung and a token with the act grant. The platform serves this route.

## Example
The example sends the smallest body that MarkLeadInput allows. The build validates it against the schema of MarkLeadInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/act/mark_lead \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "lead": "…", "condition": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.act.mark_lead({
    "lead": "…",
    "condition": "…"
  });
// answer.body is a Outcome. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/act/mark_lead",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "lead": "…",
      "condition": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/act/mark_lead")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&MarkLeadInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.act.mark_lead` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Outcome`. The [tool's page](/reference/tools/si-act-mark_lead) describes it.


---
title: "act: mark rival"
description: "a brand, the rival's entity, the evidence to the fact"
section: reference
address: /reference/act/mark_rival
contract: 0476e35e6e275db5
---

# act: mark rival

a brand, the rival's entity, the evidence to the fact

[figure: The caller sends MarkRivalInput to /v1/act/mark_rival. The platform returns a card whose body is RivalMarking.]

<span class="op-method">POST</span><span class="op-path">/v1/act/mark_rival</span>

Mark a rival. The call needs the brand rung under a token with the act grant, and it is served by the platform.

The route takes [MarkRivalInput](/concepts/markrivalinput) and returns a card whose body is [RivalMarking](/concepts/rivalmarking).



## Request body
The request body is [MarkRivalInput](/concepts/markrivalinput).



| field | type | required | note |
|---|---|---|---|
| `brand` | `id` | yes |  |
| `rival` | `id` | yes |  |
| `evidence` | [EvidenceRef](/concepts/evidenceref) | yes |  |



## Response
The route returns a card whose body is [RivalMarking](/concepts/rivalmarking). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the brand rung and a token with the act grant. The platform serves this route.

## Example
The example sends the smallest body that MarkRivalInput allows. The build validates it against the schema of MarkRivalInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/act/mark_rival \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "brand": "…", "rival": "…", "evidence": [] }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.act.mark_rival({
    "brand": "…",
    "rival": "…",
    "evidence": []
  });
// answer.body is a RivalMarking. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/act/mark_rival",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "brand": "…",
      "rival": "…",
      "evidence": []
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/act/mark_rival")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&MarkRivalInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.act.mark_rival` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/RivalMarking`. The [tool's page](/reference/tools/si-act-mark_rival) describes it.


---
title: "act: membership"
description: "the person's address, and the roles with where each is held to the membership"
section: reference
address: /reference/act/membership
contract: 0476e35e6e275db5
---

# act: membership

the person's address, and the roles with where each is held to the membership

[figure: The caller sends MembershipInput to /v1/act/membership. The platform returns a card whose body is Membership.]

<span class="op-method">POST</span><span class="op-path">/v1/act/membership</span>

Invite, suspend or remove a user, as a member or a guest. The call needs the tenant rung under a token with the act grant, and it is served by the platform.

The route takes [MembershipInput](/concepts/membershipinput) and returns a card whose body is [Membership](/concepts/membership).



## Request body
The request body is [MembershipInput](/concepts/membershipinput).



| field | type | required | note |
|---|---|---|---|
| `user` | `id` | no |  |
| `mail` | `address` | no | to invite |
| `tenant` | `id` | yes |  |
| `do` | `one of invite \| suspend \| remove` | yes |  |
| `kind` | `one of member \| guest` | no |  |



## Response
The route returns a card whose body is [Membership](/concepts/membership). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the tenant rung and a token with the act grant. The platform serves this route.

## Example
The example sends the smallest body that MembershipInput allows. The build validates it against the schema of MembershipInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/act/membership \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "tenant": "…", "do": "invite" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.act.membership({
    "tenant": "…",
    "do": "invite"
  });
// answer.body is a Membership. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/act/membership",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "tenant": "…",
      "do": "invite"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/act/membership")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&MembershipInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.act.membership` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Membership`. The [tool's page](/reference/tools/si-act-membership) describes it.


---
title: "act: move strategy"
description: "a strategy, the place to move it to and the reason (`StrategyMoveInput`): drafted, simulated, rolled out in part, running, paused, ended to the `Strategy` in its new place, with who moved it"
section: reference
address: /reference/act/move_strategy
contract: 0476e35e6e275db5
---

# act: move strategy

a strategy, the place to move it to and the reason (`StrategyMoveInput`): drafted, simulated, rolled out in part, running, paused, ended to the `Strategy` in its new place, with who moved it

[figure: The caller sends StrategyMoveInput to /v1/act/move_strategy. The platform returns a card whose body is Strategy.]

<span class="op-method">POST</span><span class="op-path">/v1/act/move_strategy</span>

Move a strategy. The call needs the strategy rung under a token with the act grant, and it is served by the platform.

The route takes [StrategyMoveInput](/concepts/strategymoveinput) and returns a card whose body is [Strategy](/concepts/strategy).



## Request body
The request body is [StrategyMoveInput](/concepts/strategymoveinput).



| field | type | required | note |
|---|---|---|---|
| `strategy` | `id` | yes |  |
| `to` | `one of drafted \| simulated \| rolled out in part \| running \| paused \| ended` | yes |  |
| `reason` | `text` | yes |  |



## Response
The route returns a card whose body is [Strategy](/concepts/strategy). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the strategy rung and a token with the act grant. The platform serves this route.

## Example
The example sends the smallest body that StrategyMoveInput allows. The build validates it against the schema of StrategyMoveInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/act/move_strategy \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "strategy": "…", "to": "drafted", "reason": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.act.move_strategy({
    "strategy": "…",
    "to": "drafted",
    "reason": "…"
  });
// answer.body is a Strategy. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/act/move_strategy",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "strategy": "…",
      "to": "drafted",
      "reason": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/act/move_strategy")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&StrategyMoveInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.act.move_strategy` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Strategy`. The [tool's page](/reference/tools/si-act-move_strategy) describes it.


---
title: "act: notification channel"
description: "Writes one notification channel, which is where a notice goes to The channel is ready once its test notice is acknowledged."
section: reference
address: /reference/act/notification_channel
contract: 0476e35e6e275db5
---

# act: notification channel

Writes one notification channel, which is where a notice goes to The channel is ready once its test notice is acknowledged.

[figure: The caller sends NotificationChannelInput to /v1/act/notification_channel. The platform returns a card whose body is NotificationChannel.]

<span class="op-method">POST</span><span class="op-path">/v1/act/notification_channel</span>

Write a notification channel. The call needs the user rung under a token with the act grant, and it is served by the platform.

The route takes [NotificationChannelInput](/concepts/notificationchannelinput) and returns a card whose body is [NotificationChannel](/concepts/notificationchannel).



## Request body
The request body is [NotificationChannelInput](/concepts/notificationchannelinput).



| field | type | required | note |
|---|---|---|---|
| `kind` | `one of in the app \| email \| Slack \| webhook \| the extension` | yes |  |
| `address` | `text` | yes |  |
| `notices` | `[text]` | yes |  |



## Response
The route returns a card whose body is [NotificationChannel](/concepts/notificationchannel). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the user rung and a token with the act grant. The platform serves this route.

## Example
The example sends the smallest body that NotificationChannelInput allows. The build validates it against the schema of NotificationChannelInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/act/notification_channel \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "kind": "in the app", "address": "…", "notices": [] }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.act.notification_channel({
    "kind": "in the app",
    "address": "…",
    "notices": []
  });
// answer.body is a NotificationChannel. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/act/notification_channel",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "kind": "in the app",
      "address": "…",
      "notices": []
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/act/notification_channel")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&NotificationChannelInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.act.notification_channel` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/NotificationChannel`. The [tool's page](/reference/tools/si-act-notification_channel) describes it.


---
title: "act: notification rule"
description: "Writes one notification rule, which says who is told and never what happens to The answer gives the rule, with the next notice it will send"
section: reference
address: /reference/act/notification_rule
contract: 0476e35e6e275db5
---

# act: notification rule

Writes one notification rule, which says who is told and never what happens to The answer gives the rule, with the next notice it will send

[figure: The caller sends NotificationRuleInput to /v1/act/notification_rule. The platform returns a card whose body is NotificationRule.]

<span class="op-method">POST</span><span class="op-path">/v1/act/notification_rule</span>

Write a notification rule. The call needs the user rung under a token with the act grant, and it is served by the platform.

The route takes [NotificationRuleInput](/concepts/notificationruleinput) and returns a card whose body is [NotificationRule](/concepts/notificationrule).



## Request body
The request body is [NotificationRuleInput](/concepts/notificationruleinput).



| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `notices` | `[text]` | yes |  |
| `channel` | [NotificationChannel](/concepts/notificationchannel) | yes |  |
| `quiet_hours` | `text` | no |  |
| `digest` | `one of none \| hourly \| daily` | yes |  |



## Response
The route returns a card whose body is [NotificationRule](/concepts/notificationrule). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the user rung and a token with the act grant. The platform serves this route.

## Example
The example sends the smallest body that NotificationRuleInput allows. The build validates it against the schema of NotificationRuleInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/act/notification_rule \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "name": "…", "notices": [], "channel": "…", "digest": "none" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.act.notification_rule({
    "name": "…",
    "notices": [],
    "channel": "…",
    "digest": "none"
  });
// answer.body is a NotificationRule. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/act/notification_rule",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "name": "…",
      "notices": [],
      "channel": "…",
      "digest": "none"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/act/notification_rule")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&NotificationRuleInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.act.notification_rule` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/NotificationRule`. The [tool's page](/reference/tools/si-act-notification_rule) describes it.


---
title: "act: parameter"
description: "a parameter by its name, its value and its scope to the parameter as written, at its new version"
section: reference
address: /reference/act/parameter
contract: 0476e35e6e275db5
---

# act: parameter

a parameter by its name, its value and its scope to the parameter as written, at its new version

[figure: The caller sends ParameterWriteInput to /v1/act/parameter. The platform returns a card whose body is Parameter.]

<span class="op-method">POST</span><span class="op-path">/v1/act/parameter</span>

Change a setting. The call needs the user rung under a token with the act grant, and it is served by the platform.

The route takes [ParameterWriteInput](/concepts/parameterwriteinput) and returns a card whose body is [Parameter](/concepts/parameter).



## Request body
The request body is [ParameterWriteInput](/concepts/parameterwriteinput).



| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `value` | `json` | yes |  |
| `scope` | [Scope](/concepts/scope) | no | the caller's tenant when absent |



## Response
The route returns a card whose body is [Parameter](/concepts/parameter). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the user rung and a token with the act grant. The platform serves this route.

## Example
The example sends the smallest body that ParameterWriteInput allows. The build validates it against the schema of ParameterWriteInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/act/parameter \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "name": "…", "value": null }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.act.parameter({
    "name": "…",
    "value": null
  });
// answer.body is a Parameter. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/act/parameter",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "name": "…",
      "value": null
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/act/parameter")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&ParameterWriteInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.act.parameter` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Parameter`. The [tool's page](/reference/tools/si-act-parameter) describes it.


---
title: "act: place participant"
description: "Places one party in one role on one stock of a vertical's chain, with the evidence for it to The answer gives the participant, ready or not ready with the reason"
section: reference
address: /reference/act/place_participant
contract: 0476e35e6e275db5
---

# act: place participant

Places one party in one role on one stock of a vertical's chain, with the evidence for it to The answer gives the participant, ready or not ready with the reason

[figure: The caller sends PlaceParticipantInput to /v1/act/place_participant. The platform returns a card whose body is MarketParticipant.]

<span class="op-method">POST</span><span class="op-path">/v1/act/place_participant</span>

Place a participant. The call needs the brand rung under a token with the act grant, and it is served by the platform.

The route takes [PlaceParticipantInput](/concepts/placeparticipantinput) and returns a card whose body is [MarketParticipant](/concepts/marketparticipant).



## Request body
The request body is [PlaceParticipantInput](/concepts/placeparticipantinput).



| field | type | required | note |
|---|---|---|---|
| `vertical` | `id` | yes |  |
| `segment` | `id` | no |  |
| `stock` | `text` | yes |  |
| `party` | `id` | yes |  |
| `party_kind` | `one of company \| brand \| person \| account \| community \| organisation` | yes |  |
| `role` | [RoleAroundADecision](/concepts/rolearoundadecision) | yes |  |
| `side` | `one of demand \| supply \| intermediary \| influence \| rules` | yes |  |
| `impact_on` | [ParticipantImpact](/concepts/participantimpact) | no |  |
| `evidence` | [EvidenceRef](/concepts/evidenceref) | yes |  |



## Response
The route returns a card whose body is [MarketParticipant](/concepts/marketparticipant). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the brand rung and a token with the act grant. The platform serves this route.

## Example
The example sends the smallest body that PlaceParticipantInput allows. The build validates it against the schema of PlaceParticipantInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/act/place_participant \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "vertical": "…", "stock": "…", "party": "…", "party_kind": "company", "role": "…", "side": "demand", "evidence": [] }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.act.place_participant({
    "vertical": "…",
    "stock": "…",
    "party": "…",
    "party_kind": "company",
    "role": "…",
    "side": "demand",
    "evidence": []
  });
// answer.body is a MarketParticipant. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/act/place_participant",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "vertical": "…",
      "stock": "…",
      "party": "…",
      "party_kind": "company",
      "role": "…",
      "side": "demand",
      "evidence": []
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/act/place_participant")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&PlaceParticipantInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.act.place_participant` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/MarketParticipant`. The [tool's page](/reference/tools/si-act-place_participant) describes it.


---
title: "act: probe identity"
description: "the identity to its readiness with the reason"
section: reference
address: /reference/act/probe_identity
contract: 0476e35e6e275db5
---

# act: probe identity

the identity to its readiness with the reason

[figure: The caller sends ProbeIdentityInput to /v1/act/probe_identity. The platform returns a card whose body is Readiness.]

<span class="op-method">POST</span><span class="op-path">/v1/act/probe_identity</span>

Probe a held identity. The call needs the tenant rung under a token with the act grant, and it is served by the platform.

The route takes [ProbeIdentityInput](/concepts/probeidentityinput) and returns a card whose body is [Readiness](/concepts/readiness).



## Request body
The request body is [ProbeIdentityInput](/concepts/probeidentityinput).



| field | type | required | note |
|---|---|---|---|
| `identity` | `id` | yes |  |



## Response
The route returns a card whose body is [Readiness](/concepts/readiness). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the tenant rung and a token with the act grant. The platform serves this route.

## Example
The example sends the smallest body that ProbeIdentityInput allows. The build validates it against the schema of ProbeIdentityInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/act/probe_identity \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "identity": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.act.probe_identity({
    "identity": "…"
  });
// answer.body is a Readiness. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/act/probe_identity",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "identity": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/act/probe_identity")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&ProbeIdentityInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.act.probe_identity` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Readiness`. The [tool's page](/reference/tools/si-act-probe_identity) describes it.


---
title: "act: propose move"
description: "a match of a play to the move, proposed, with its forecast and its assignments as facts"
section: reference
address: /reference/act/propose_move
contract: 0476e35e6e275db5
---

# act: propose move

a match of a play to the move, proposed, with its forecast and its assignments as facts

[figure: The caller sends ProposeMoveInput to /v1/act/propose_move. The platform returns a card whose body is Move.]

<span class="op-method">POST</span><span class="op-path">/v1/act/propose_move</span>

Propose a move. The call needs the strategy rung under a token with the act grant, and it is served by the platform.

The route takes [ProposeMoveInput](/concepts/proposemoveinput) and returns a card whose body is [Move](/concepts/move).



## Request body
The request body is [ProposeMoveInput](/concepts/proposemoveinput).



| field | type | required | note |
|---|---|---|---|
| `play` | `id` | yes |  |
| `catch` | `id` | no |  |
| `strategy` | `id` | yes |  |



## Response
The route returns a card whose body is [Move](/concepts/move). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the strategy rung and a token with the act grant. The platform serves this route.

## Example
The example sends the smallest body that ProposeMoveInput allows. The build validates it against the schema of ProposeMoveInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/act/propose_move \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "play": "…", "strategy": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.act.propose_move({
    "play": "…",
    "strategy": "…"
  });
// answer.body is a Move. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/act/propose_move",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "play": "…",
      "strategy": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/act/propose_move")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&ProposeMoveInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.act.propose_move` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Move`. The [tool's page](/reference/tools/si-act-propose_move) describes it.


---
title: "act: publish"
description: "the version, the address, the visibility to the publishing, proposed or published, and its receipt"
section: reference
address: /reference/act/publish
contract: 0476e35e6e275db5
---

# act: publish

the version, the address, the visibility to the publishing, proposed or published, and its receipt

[figure: The caller sends PublishInput to /v1/act/publish. The platform returns a card whose body is Publishing.]

<span class="op-method">POST</span><span class="op-path">/v1/act/publish</span>

Publish. The call needs the brand rung under a token with the act grant, and it is served by the platform.

The route takes [PublishInput](/concepts/publishinput) and returns a card whose body is [Publishing](/concepts/publishing).



## Request body
The request body is [PublishInput](/concepts/publishinput).



| field | type | required | note |
|---|---|---|---|
| `build` | `id` | yes |  |
| `address` | `address` | yes |  |
| `key` | `id` | no |  |



## Response
The route returns a card whose body is [Publishing](/concepts/publishing). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the brand rung and a token with the act grant. The platform serves this route.

## Example
The example sends the smallest body that PublishInput allows. The build validates it against the schema of PublishInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/act/publish \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "build": "…", "address": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.act.publish({
    "build": "…",
    "address": "…"
  });
// answer.body is a Publishing. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/act/publish",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "build": "…",
      "address": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/act/publish")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&PublishInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.act.publish` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Publishing`. The [tool's page](/reference/tools/si-act-publish) describes it.


---
title: "act: raise need"
description: "a cell's key, the reason and the value to the cell, wanted"
section: reference
address: /reference/act/raise_need
contract: 0476e35e6e275db5
---

# act: raise need

a cell's key, the reason and the value to the cell, wanted

[figure: The caller sends RaiseNeedInput to /v1/act/raise_need. The platform returns a card whose body is DemandCell.]

<span class="op-method">POST</span><span class="op-path">/v1/act/raise_need</span>

Raise a need. The call needs the brand rung under a token with the act grant, and it is served by the platform.

The route takes [RaiseNeedInput](/concepts/raiseneedinput) and returns a card whose body is [DemandCell](/concepts/demandcell).



## Request body
The request body is [RaiseNeedInput](/concepts/raiseneedinput).



| field | type | required | note |
|---|---|---|---|
| `source` | [Source](/concepts/source) | yes |  |
| `entities` | [Predicate](/concepts/predicate) | yes |  |
| `bucket` | [Window](/concepts/window) | yes |  |
| `fields` | `[text]` | yes |  |
| `value` | `share` | yes |  |



## Response
The route returns a card whose body is [DemandCell](/concepts/demandcell). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the brand rung and a token with the act grant. The platform serves this route.

## Example
The example sends the smallest body that RaiseNeedInput allows. The build validates it against the schema of RaiseNeedInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/act/raise_need \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "source": "…", "entities": { "tree": { "form": "group" }, "population": "…", "tree_hash": "…", "register_hash": "…", "compiler_version": "…", "comparator_versions": {} }, "bucket": { "from": "…", "to": "…" }, "fields": [], "value": 0 }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.act.raise_need({
    "source": "…",
    "entities": {
      "tree": {
        "form": "group"
      },
      "population": "…",
      "tree_hash": "…",
      "register_hash": "…",
      "compiler_version": "…",
      "comparator_versions": {}
    },
    "bucket": {
      "from": "…",
      "to": "…"
    },
    "fields": [],
    "value": 0
  });
// answer.body is a DemandCell. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/act/raise_need",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "source": "…",
      "entities": {
        "tree": {
          "form": "group"
        },
        "population": "…",
        "tree_hash": "…",
        "register_hash": "…",
        "compiler_version": "…",
        "comparator_versions": {}
      },
      "bucket": {
        "from": "…",
        "to": "…"
      },
      "fields": [],
      "value": 0
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/act/raise_need")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&RaiseNeedInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.act.raise_need` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/DemandCell`. The [tool's page](/reference/tools/si-act-raise_need) describes it.


---
title: "act: record fit reading"
description: "Records one result of a person's own test: the tactic, the market, the measure, its value, the sample and where it came from to The answer gives the reading as a fact the record keeps"
section: reference
address: /reference/act/record_fit_reading
contract: 0476e35e6e275db5
---

# act: record fit reading

Records one result of a person's own test: the tactic, the market, the measure, its value, the sample and where it came from to The answer gives the reading as a fact the record keeps

[figure: The caller sends FitReadingInput to /v1/act/record_fit_reading. The platform returns a card whose body is FitReading.]

<span class="op-method">POST</span><span class="op-path">/v1/act/record_fit_reading</span>

Record a fit reading. The call needs the brand rung under a token with the act grant, and it is served by the platform.

The route takes [FitReadingInput](/concepts/fitreadinginput) and returns a card whose body is [FitReading](/concepts/fitreading).



## Request body
The request body is [FitReadingInput](/concepts/fitreadinginput).



| field | type | required | note |
|---|---|---|---|
| `tactic` | [Tactic](/concepts/tactic) | yes |  |
| `vertical` | `id` | yes |  |
| `segment` | `id` | no |  |
| `offering` | `id` | no |  |
| `measure` | [KindOfMeasure](/concepts/kindofmeasure) | yes |  |
| `value` | `json` | yes | the number, or never measured with the reason |
| `sample` | `count` | no |  |
| `source` | `one of a form \| a CRM \| a capture \| an upload \| a call \| the record` | yes |  |
| `hypothesis` | `id` | no |  |
| `note` | `text` | no |  |



## Response
The route returns a card whose body is [FitReading](/concepts/fitreading). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the brand rung and a token with the act grant. The platform serves this route.

## Example
The example sends the smallest body that FitReadingInput allows. The build validates it against the schema of FitReadingInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/act/record_fit_reading \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "tactic": "…", "vertical": "…", "measure": "…", "value": null, "source": "a form" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.act.record_fit_reading({
    "tactic": "…",
    "vertical": "…",
    "measure": "…",
    "value": null,
    "source": "a form"
  });
// answer.body is a FitReading. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/act/record_fit_reading",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "tactic": "…",
      "vertical": "…",
      "measure": "…",
      "value": null,
      "source": "a form"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/act/record_fit_reading")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&FitReadingInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.act.record_fit_reading` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/FitReading`. The [tool's page](/reference/tools/si-act-record_fit_reading) describes it.


---
title: "act: remember"
description: "a memory and its scope to the memory, or a later fact that ends it"
section: reference
address: /reference/act/remember
contract: 0476e35e6e275db5
---

# act: remember

a memory and its scope to the memory, or a later fact that ends it

[figure: The caller sends RememberInput to /v1/act/remember. The platform returns a card whose body is Memory.]

<span class="op-method">POST</span><span class="op-path">/v1/act/remember</span>

Remember, or forget. The call needs the strategy rung under a token with the act grant, and it is served by the platform.

The route takes [RememberInput](/concepts/rememberinput) and returns a card whose body is [Memory](/concepts/memory).



## Request body
The request body is [RememberInput](/concepts/rememberinput).



| field | type | required | note |
|---|---|---|---|
| `memory` | [Memory](/concepts/memory) | no |  |
| `forget` | `id` | no |  |



## Response
The route returns a card whose body is [Memory](/concepts/memory). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the strategy rung and a token with the act grant. The platform serves this route.

## Example
The example sends the smallest body that RememberInput allows. The build validates it against the schema of RememberInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/act/remember \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{}'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.act.remember({});
// answer.body is a Memory. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/act/remember",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={}).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/act/remember")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&RememberInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.act.remember` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Memory`. The [tool's page](/reference/tools/si-act-remember) describes it.


---
title: "act: routing"
description: "Writes, previews or arms a routing rule from a predicate and the people or the team it attaches to A write or an arm gives the rule."
section: reference
address: /reference/act/routing
contract: 0476e35e6e275db5
---

# act: routing

Writes, previews or arms a routing rule from a predicate and the people or the team it attaches to A write or an arm gives the rule.

[figure: The caller sends RoutingInput to /v1/act/routing. The platform returns a card whose body is RoutingAnswer.]

<span class="op-method">POST</span><span class="op-path">/v1/act/routing</span>

Write, preview and arm a routing rule. The call needs the brand rung under a token with the act grant, and it is served by the platform.

The route takes [RoutingInput](/concepts/routinginput) and returns a card whose body is [RoutingAnswer](/concepts/routinganswer).



## Request body
The request body is [RoutingInput](/concepts/routinginput).



| field | type | required | note |
|---|---|---|---|
| `rule` | [RoutingRule](/concepts/routingrule) | yes |  |
| `do` | `one of write \| preview \| arm` | yes |  |



## Response
The route returns a card whose body is [RoutingAnswer](/concepts/routinganswer). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the brand rung and a token with the act grant. The platform serves this route.

## Example
The example sends the smallest body that RoutingInput allows. The build validates it against the schema of RoutingInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/act/routing \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "rule": { "name": "…", "predicate": "…", "to": { "kind": "a user", "id": "…" }, "armed": false }, "do": "write" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.act.routing({
    "rule": {
      "name": "…",
      "predicate": "…",
      "to": {
        "kind": "a user",
        "id": "…"
      },
      "armed": false
    },
    "do": "write"
  });
// answer.body is a RoutingAnswer. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/act/routing",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "rule": {
        "name": "…",
        "predicate": "…",
        "to": {
          "kind": "a user",
          "id": "…"
        },
        "armed": false
      },
      "do": "write"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/act/routing")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&RoutingInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.act.routing` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/RoutingAnswer`. The [tool's page](/reference/tools/si-act-routing) describes it.


---
title: "act: run action"
description: "an action prepared by a move to the action, allowed or not allowed with the reason, then running, then done or failed"
section: reference
address: /reference/act/run_action
contract: 0476e35e6e275db5
---

# act: run action

an action prepared by a move to the action, allowed or not allowed with the reason, then running, then done or failed

[figure: The caller sends RunActionInput to /v1/act/run_action. The platform returns a card whose body is Action.]

<span class="op-method">POST</span><span class="op-path">/v1/act/run_action</span><span class="op-note">a task, 202</span>

Run an action. The call needs the strategy rung under a token with the act grant, and it is served by the platform.

The route takes [RunActionInput](/concepts/runactioninput) and returns a card whose body is [Action](/concepts/action).



## Request body
The request body is [RunActionInput](/concepts/runactioninput).



| field | type | required | note |
|---|---|---|---|
| `action` | `id` | yes |  |



## Response
The route returns a card whose body is [Action](/concepts/action). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true. This route runs as a long step and returns a task with status 202. `POST /v1/work/status` returns the task's progress, and `POST /v1/work/cancel` stops the task.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the strategy rung and a token with the act grant. The platform serves this route.

## Example
The example sends the smallest body that RunActionInput allows. The build validates it against the schema of RunActionInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/act/run_action \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "action": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.act.run_action({
    "action": "…"
  });
// answer.body is a Action. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/act/run_action",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "action": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/act/run_action")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&RunActionInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.act.run_action` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Action`. The [tool's page](/reference/tools/si-act-run_action) describes it.


---
title: "act: scrape template"
description: "a `TemplateInput` to the template, ready or not ready with the reason; for a preview, the rows from its samples and a bounded live scope"
section: reference
address: /reference/act/scrape_template
contract: 0476e35e6e275db5
---

# act: scrape template

a `TemplateInput` to the template, ready or not ready with the reason; for a preview, the rows from its samples and a bounded live scope

[figure: The caller sends TemplateInput to /v1/act/scrape_template. The platform returns a card whose body is ExtractionTemplate.]

<span class="op-method">POST</span><span class="op-path">/v1/act/scrape_template</span>

Write, preview, arm or retire a scrape template. The call needs the brand rung under a token with the act grant, and it is served by the platform.

The route takes [TemplateInput](/concepts/templateinput) and returns a card whose body is [ExtractionTemplate](/concepts/extractiontemplate).



## Request body
The request body is [TemplateInput](/concepts/templateinput).



| field | type | required | note |
|---|---|---|---|
| `template` | [ExtractionTemplate](/concepts/extractiontemplate) | yes |  |
| `flow` | `one of write \| preview \| arm \| disarm \| retire` | yes |  |



## Response
The route returns a card whose body is [ExtractionTemplate](/concepts/extractiontemplate). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the brand rung and a token with the act grant. The platform serves this route.

## Example
The example sends the smallest body that TemplateInput allows. The build validates it against the schema of TemplateInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/act/scrape_template \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "template": { "name": "…", "page_kind": "listing", "scope": { "seeds": [], "allow_patterns": [], "deny_patterns": [], "max_depth": 0, "max_pages": 0, "use_sitemap": false }, "render": "static", "navigation": [], "fields": [], "normalisation": [], "dedup_key": [], "source_object": "…", "filter": { "allow_types": [], "deny_types": [], "allow_patterns": [], "deny_patterns": [], "render": "static" }, "freshness": "…", "attempt_caps": {}, "budget": {}, "state": { "ready": false, "since": "…" } }, "flow": "write" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.act.scrape_template({
    "template": {
      "name": "…",
      "page_kind": "listing",
      "scope": {
        "seeds": [],
        "allow_patterns": [],
        "deny_patterns": [],
        "max_depth": 0,
        "max_pages": 0,
        "use_sitemap": false
      },
      "render": "static",
      "navigation": [],
      "fields": [],
      "normalisation": [],
      "dedup_key": [],
      "source_object": "…",
      "filter": {
        "allow_types": [],
        "deny_types": [],
        "allow_patterns": [],
        "deny_patterns": [],
        "render": "static"
      },
      "freshness": "…",
      "attempt_caps": {},
      "budget": {},
      "state": {
        "ready": false,
        "since": "…"
      }
    },
    "flow": "write"
  });
// answer.body is a ExtractionTemplate. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/act/scrape_template",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "template": {
        "name": "…",
        "page_kind": "listing",
        "scope": {
          "seeds": [],
          "allow_patterns": [],
          "deny_patterns": [],
          "max_depth": 0,
          "max_pages": 0,
          "use_sitemap": false
        },
        "render": "static",
        "navigation": [],
        "fields": [],
        "normalisation": [],
        "dedup_key": [],
        "source_object": "…",
        "filter": {
          "allow_types": [],
          "deny_types": [],
          "allow_patterns": [],
          "deny_patterns": [],
          "render": "static"
        },
        "freshness": "…",
        "attempt_caps": {},
        "budget": {},
        "state": {
          "ready": false,
          "since": "…"
        }
      },
      "flow": "write"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/act/scrape_template")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&TemplateInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.act.scrape_template` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/ExtractionTemplate`. The [tool's page](/reference/tools/si-act-scrape_template) describes it.


---
title: "act: seed tenant"
description: "the manifest and the window to the seed as work, then its receipt with counts by kind and what is not ready"
section: reference
address: /reference/act/seed_tenant
contract: 0476e35e6e275db5
---

# act: seed tenant

the manifest and the window to the seed as work, then its receipt with counts by kind and what is not ready

[figure: The caller sends SeedInput to /v1/act/seed_tenant. The platform returns a card whose body is SeedReceipt.]

<span class="op-method">POST</span><span class="op-path">/v1/act/seed_tenant</span><span class="op-note">a task, 202</span>

Seed a tenant from a manifest. The call needs the platform rung under a token with the admin grant, and it is served by the platform.

The route takes [SeedInput](/concepts/seedinput) and returns a card whose body is [SeedReceipt](/concepts/seedreceipt).



## Request body
The request body is [SeedInput](/concepts/seedinput).



| field | type | required | note |
|---|---|---|---|
| `manifest` | `id` | yes |  |
| `window_months` | `count` | no | the parameter's value when empty |



## Response
The route returns a card whose body is [SeedReceipt](/concepts/seedreceipt). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true. This route runs as a long step and returns a task with status 202. `POST /v1/work/status` returns the task's progress, and `POST /v1/work/cancel` stops the task.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the platform rung and a token with the admin grant. The platform serves this route.

## Example
The example sends the smallest body that SeedInput allows. The build validates it against the schema of SeedInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/act/seed_tenant \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "manifest": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.act.seed_tenant({
    "manifest": "…"
  });
// answer.body is a SeedReceipt. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/act/seed_tenant",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "manifest": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/act/seed_tenant")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&SeedInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.act.seed_tenant` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/SeedReceipt`. The [tool's page](/reference/tools/si-act-seed_tenant) describes it.


---
title: "act: set aside run"
description: "a `SetAsideRunInput`: the run's key and a person's plain reason to the `ScrapeRun`, kept in the parked place with the reason, which the beat never takes up; each move is an event with the reason"
section: reference
address: /reference/act/set_aside_run
contract: 0476e35e6e275db5
---

# act: set aside run

a `SetAsideRunInput`: the run's key and a person's plain reason to the `ScrapeRun`, kept in the parked place with the reason, which the beat never takes up; each move is an event with the reason

[figure: The caller sends SetAsideRunInput to /v1/act/set_aside_run. The platform returns a card whose body is ScrapeRun.]

<span class="op-method">POST</span><span class="op-path">/v1/act/set_aside_run</span>

Set a run aside. The call needs the tenant rung under a token with the act grant, and it is served by the platform.

The route takes [SetAsideRunInput](/concepts/setasideruninput) and returns a card whose body is [ScrapeRun](/concepts/scraperun).



## Request body
The request body is [SetAsideRunInput](/concepts/setasideruninput).



| field | type | required | note |
|---|---|---|---|
| `run` | `text` | yes | the run's key, as the runs read lists it |
| `reason` | `text` | yes | the plain reason the run waits, which its row and its event carry |



## Response
The route returns a card whose body is [ScrapeRun](/concepts/scraperun). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the tenant rung and a token with the act grant. The platform serves this route.

## Example
The example sends the smallest body that SetAsideRunInput allows. The build validates it against the schema of SetAsideRunInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/act/set_aside_run \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "run": "…", "reason": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.act.set_aside_run({
    "run": "…",
    "reason": "…"
  });
// answer.body is a ScrapeRun. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/act/set_aside_run",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "run": "…",
      "reason": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/act/set_aside_run")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&SetAsideRunInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.act.set_aside_run` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/ScrapeRun`. The [tool's page](/reference/tools/si-act-set_aside_run) describes it.


---
title: "act: settle"
description: "a hypothesis, the standing, the caller to the hypothesis settled, with who settled it and on what"
section: reference
address: /reference/act/settle
contract: 0476e35e6e275db5
---

# act: settle

a hypothesis, the standing, the caller to the hypothesis settled, with who settled it and on what

[figure: The caller sends SettleInput to /v1/act/settle. The platform returns a card whose body is Hypothesis.]

<span class="op-method">POST</span><span class="op-path">/v1/act/settle</span>

Settle a claim. The call needs the strategy rung under a token with the act grant, and it is served by either, by the size bound.

The route takes [SettleInput](/concepts/settleinput) and returns a card whose body is [Hypothesis](/concepts/hypothesis).



## Request body
The request body is [SettleInput](/concepts/settleinput).



| field | type | required | note |
|---|---|---|---|
| `hypothesis` | `id` | yes |  |
| `standing` | `one of supported \| refuted \| cannot tell \| under test` | yes |  |
| `on` | `text` | yes | what it was settled on |



## Response
The route returns a card whose body is [Hypothesis](/concepts/hypothesis). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the strategy rung and a token with the act grant. The platform or the desktop app serves this route.

## Example
The example sends the smallest body that SettleInput allows. The build validates it against the schema of SettleInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/act/settle \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "hypothesis": "…", "standing": "supported", "on": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.act.settle({
    "hypothesis": "…",
    "standing": "supported",
    "on": "…"
  });
// answer.body is a Hypothesis. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/act/settle",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "hypothesis": "…",
      "standing": "supported",
      "on": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/act/settle")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&SettleInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.act.settle` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Hypothesis`. The [tool's page](/reference/tools/si-act-settle) describes it.


---
title: "act: settle match"
description: "the possible match, and a user's answer or a proof to confirmed, with the merge."
section: reference
address: /reference/act/settle_match
contract: 0476e35e6e275db5
---

# act: settle match

the possible match, and a user's answer or a proof to confirmed, with the merge.

[figure: The caller sends SettleMatchInput to /v1/act/settle_match. The platform returns a card whose body is SettleMatchAnswer.]

<span class="op-method">POST</span><span class="op-path">/v1/act/settle_match</span>

Settle a possible match. The call needs the brand rung under a token with the act grant, and it is served by the platform.

The route takes [SettleMatchInput](/concepts/settlematchinput) and returns a card whose body is [SettleMatchAnswer](/concepts/settlematchanswer).



## Request body
The request body is [SettleMatchInput](/concepts/settlematchinput).



| field | type | required | note |
|---|---|---|---|
| `match` | `id` | yes |  |
| `decision` | `one of confirm \| reject` | yes |  |
| `evidence` | [EvidenceRef](/concepts/evidenceref) | no |  |



## Response
The route returns a card whose body is [SettleMatchAnswer](/concepts/settlematchanswer). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the brand rung and a token with the act grant. The platform serves this route.

## Example
The example sends the smallest body that SettleMatchInput allows. The build validates it against the schema of SettleMatchInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/act/settle_match \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "match": "…", "decision": "confirm" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.act.settle_match({
    "match": "…",
    "decision": "confirm"
  });
// answer.body is a SettleMatchAnswer. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/act/settle_match",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "match": "…",
      "decision": "confirm"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/act/settle_match")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&SettleMatchInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.act.settle_match` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/SettleMatchAnswer`. The [tool's page](/reference/tools/si-act-settle_match) describes it.


---
title: "act: sign up"
description: "the company's name, and its domain where known, from a signed-in person who belongs to no tenant to the tenant, made on the trial plan with the person as its first member and owner, in one transaction with its events"
section: reference
address: /reference/act/sign_up
contract: 0476e35e6e275db5
---

# act: sign up

the company's name, and its domain where known, from a signed-in person who belongs to no tenant to the tenant, made on the trial plan with the person as its first member and owner, in one transaction with its events

[figure: The caller sends SignUpInput to /v1/act/sign_up. The platform returns a card whose body is Tenant.]

<span class="op-method">POST</span><span class="op-path">/v1/act/sign_up</span>

Sign up. The call needs the user rung under a token with the act grant, and it is served by the platform.

The route takes [SignUpInput](/concepts/signupinput) and returns a card whose body is [Tenant](/concepts/tenant).



## Request body
The request body is [SignUpInput](/concepts/signupinput).



| field | type | required | note |
|---|---|---|---|
| `company` | `text` | yes | the company's name as the person states it |
| `domain` | `text` | no | the company's website, which the map from a domain reads next |



## Response
The route returns a card whose body is [Tenant](/concepts/tenant). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the user rung and a token with the act grant. The platform serves this route.

## Example
The example sends the smallest body that SignUpInput allows. The build validates it against the schema of SignUpInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/act/sign_up \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "company": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.act.sign_up({
    "company": "…"
  });
// answer.body is a Tenant. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/act/sign_up",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "company": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/act/sign_up")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&SignUpInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.act.sign_up` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Tenant`. The [tool's page](/reference/tools/si-act-sign_up) describes it.


---
title: "act: strategy"
description: "a brand or brands, a name, a window if any to the strategy, with the standing measures"
section: reference
address: /reference/act/strategy
contract: 0476e35e6e275db5
---

# act: strategy

a brand or brands, a name, a window if any to the strategy, with the standing measures

[figure: The caller sends StrategyInput to /v1/act/strategy. The platform returns a card whose body is Strategy.]

<span class="op-method">POST</span><span class="op-path">/v1/act/strategy</span>

Make a strategy. The call needs the brand rung under a token with the act grant, and it is served by the platform.

The route takes [StrategyInput](/concepts/strategyinput) and returns a card whose body is [Strategy](/concepts/strategy).



## Request body
The request body is [StrategyInput](/concepts/strategyinput).



| field | type | required | note |
|---|---|---|---|
| `strategy` | [Strategy](/concepts/strategy) | yes |  |



## Response
The route returns a card whose body is [Strategy](/concepts/strategy). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the brand rung and a token with the act grant. The platform serves this route.

## Example
The example sends the smallest body that StrategyInput allows. The build validates it against the schema of StrategyInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/act/strategy \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "strategy": { "name": "…", "brands": [], "goals": [], "plays": [], "monitors": [], "moves": [], "budget": { "money_outside": 0, "model_calls": 0, "workbench_time": "…", "people_hours": "…", "spent": {}, "window": { "from": "…", "to": "…" } }, "people": [], "grants": [], "memory": [], "tasks": [], "window": { "from": "…", "to": "…" }, "standing": false, "life": "drafted", "version": 0, "game": "…", "graph": [], "simulations": [], "policy": "…" } }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.act.strategy({
    "strategy": {
      "name": "…",
      "brands": [],
      "goals": [],
      "plays": [],
      "monitors": [],
      "moves": [],
      "budget": {
        "money_outside": 0,
        "model_calls": 0,
        "workbench_time": "…",
        "people_hours": "…",
        "spent": {},
        "window": {
          "from": "…",
          "to": "…"
        }
      },
      "people": [],
      "grants": [],
      "memory": [],
      "tasks": [],
      "window": {
        "from": "…",
        "to": "…"
      },
      "standing": false,
      "life": "drafted",
      "version": 0,
      "game": "…",
      "graph": [],
      "simulations": [],
      "policy": "…"
    }
  });
// answer.body is a Strategy. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/act/strategy",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "strategy": {
        "name": "…",
        "brands": [],
        "goals": [],
        "plays": [],
        "monitors": [],
        "moves": [],
        "budget": {
          "money_outside": 0,
          "model_calls": 0,
          "workbench_time": "…",
          "people_hours": "…",
          "spent": {},
          "window": {
            "from": "…",
            "to": "…"
          }
        },
        "people": [],
        "grants": [],
        "memory": [],
        "tasks": [],
        "window": {
          "from": "…",
          "to": "…"
        },
        "standing": false,
        "life": "drafted",
        "version": 0,
        "game": "…",
        "graph": [],
        "simulations": [],
        "policy": "…"
      }
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/act/strategy")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&StrategyInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.act.strategy` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Strategy`. The [tool's page](/reference/tools/si-act-strategy) describes it.


---
title: "act: sync rule"
description: "the installed connector, the offer, the fields of section 2.8 to the rule; for a preview, what it would read and push"
section: reference
address: /reference/act/sync_rule
contract: 0476e35e6e275db5
---

# act: sync rule

the installed connector, the offer, the fields of section 2.8 to the rule; for a preview, what it would read and push

[figure: The caller sends SyncRuleInput to /v1/act/sync_rule. The platform returns a card whose body is SyncPreview.]

<span class="op-method">POST</span><span class="op-path">/v1/act/sync_rule</span>

Write, preview and arm a sync rule. The call needs the brand rung under a token with the act grant, and it is served by the platform.

The route takes [SyncRuleInput](/concepts/syncruleinput) and returns a card whose body is [SyncPreview](/concepts/syncpreview).



## Request body
The request body is [SyncRuleInput](/concepts/syncruleinput).



| field | type | required | note |
|---|---|---|---|
| `rule` | [SyncRule](/concepts/syncrule) | yes |  |
| `flow` | `one of write \| preview \| arm \| disarm` | yes |  |



## Response
The route returns a card whose body is [SyncPreview](/concepts/syncpreview). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the brand rung and a token with the act grant. The platform serves this route.

## Example
The example sends the smallest body that SyncRuleInput allows. The build validates it against the schema of SyncRuleInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/act/sync_rule \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "rule": { "installed_connector": "…", "offer": { "reading": "…", "action": "…", "identity_link": "…", "directions": [] }, "direction": "pull", "push_mappings": [], "conflict": "the source wins", "grant": "…", "state": { "ready": false, "since": "…" } }, "flow": "write" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.act.sync_rule({
    "rule": {
      "installed_connector": "…",
      "offer": {
        "reading": "…",
        "action": "…",
        "identity_link": "…",
        "directions": []
      },
      "direction": "pull",
      "push_mappings": [],
      "conflict": "the source wins",
      "grant": "…",
      "state": {
        "ready": false,
        "since": "…"
      }
    },
    "flow": "write"
  });
// answer.body is a SyncPreview. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/act/sync_rule",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "rule": {
        "installed_connector": "…",
        "offer": {
          "reading": "…",
          "action": "…",
          "identity_link": "…",
          "directions": []
        },
        "direction": "pull",
        "push_mappings": [],
        "conflict": "the source wins",
        "grant": "…",
        "state": {
          "ready": false,
          "since": "…"
        }
      },
      "flow": "write"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/act/sync_rule")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&SyncRuleInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.act.sync_rule` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/SyncPreview`. The [tool's page](/reference/tools/si-act-sync_rule) describes it.


---
title: "act: undo"
description: "a done action to the action, undone, and the inverse's own action"
section: reference
address: /reference/act/undo
contract: 0476e35e6e275db5
---

# act: undo

a done action to the action, undone, and the inverse's own action

[figure: The caller sends UndoInput to /v1/act/undo. The platform returns a card whose body is UndoAnswer.]

<span class="op-method">POST</span><span class="op-path">/v1/act/undo</span>

Undo an action. The call needs the strategy rung under a token with the act grant, and it is served by the platform.

The route takes [UndoInput](/concepts/undoinput) and returns a card whose body is [UndoAnswer](/concepts/undoanswer).



## Request body
The request body is [UndoInput](/concepts/undoinput).



| field | type | required | note |
|---|---|---|---|
| `action` | `id` | yes |  |
| `reason` | `text` | yes |  |



## Response
The route returns a card whose body is [UndoAnswer](/concepts/undoanswer). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the strategy rung and a token with the act grant. The platform serves this route.

## Example
The example sends the smallest body that UndoInput allows. The build validates it against the schema of UndoInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/act/undo \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "action": "…", "reason": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.act.undo({
    "action": "…",
    "reason": "…"
  });
// answer.body is a UndoAnswer. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/act/undo",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "action": "…",
      "reason": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/act/undo")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&UndoInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.act.undo` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/UndoAnswer`. The [tool's page](/reference/tools/si-act-undo) describes it.


---
title: "act: undo action"
description: "the move to the inverse move"
section: reference
address: /reference/act/undo_action
contract: 0476e35e6e275db5
---

# act: undo action

the move to the inverse move

[figure: The caller sends UndoActionInput to /v1/act/undo_action. The platform returns a card whose body is Move.]

<span class="op-method">POST</span><span class="op-path">/v1/act/undo_action</span>

Undo an action. The call needs the brand rung under a token with the act grant, and it is served by the platform.

The route takes [UndoActionInput](/concepts/undoactioninput) and returns a card whose body is [Move](/concepts/move).



## Request body
The request body is [UndoActionInput](/concepts/undoactioninput).



| field | type | required | note |
|---|---|---|---|
| `move` | `id` | yes |  |



## Response
The route returns a card whose body is [Move](/concepts/move). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the brand rung and a token with the act grant. The platform serves this route.

## Example
The example sends the smallest body that UndoActionInput allows. The build validates it against the schema of UndoActionInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/act/undo_action \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "move": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.act.undo_action({
    "move": "…"
  });
// answer.body is a Move. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/act/undo_action",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "move": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/act/undo_action")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&UndoActionInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.act.undo_action` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Move`. The [tool's page](/reference/tools/si-act-undo_action) describes it.


---
title: "act: undo merge"
description: "the merge or the decision, and the reason to a parting."
section: reference
address: /reference/act/undo_merge
contract: 0476e35e6e275db5
---

# act: undo merge

the merge or the decision, and the reason to a parting.

[figure: The caller sends UndoMergeInput to /v1/act/undo_merge. The platform returns a card whose body is UndoMergeAnswer.]

<span class="op-method">POST</span><span class="op-path">/v1/act/undo_merge</span>

Undo a merge. Undo a decision. The call needs the brand rung under a token with the act grant, and it is served by the platform.

The route takes [UndoMergeInput](/concepts/undomergeinput) and returns a card whose body is [UndoMergeAnswer](/concepts/undomergeanswer).



## Request body
The request body is [UndoMergeInput](/concepts/undomergeinput).



| field | type | required | note |
|---|---|---|---|
| `merge` | `id` | no |  |
| `decision` | `id` | no |  |
| `reason` | `text` | yes |  |



## Response
The route returns a card whose body is [UndoMergeAnswer](/concepts/undomergeanswer). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the brand rung and a token with the act grant. The platform serves this route.

## Example
The example sends the smallest body that UndoMergeInput allows. The build validates it against the schema of UndoMergeInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/act/undo_merge \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "reason": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.act.undo_merge({
    "reason": "…"
  });
// answer.body is a UndoMergeAnswer. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/act/undo_merge",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "reason": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/act/undo_merge")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&UndoMergeInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.act.undo_merge` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/UndoMergeAnswer`. The [tool's page](/reference/tools/si-act-undo_merge) describes it.


---
title: "act: watch"
description: "a public entity to a watched identity, with its monitor armed"
section: reference
address: /reference/act/watch
contract: 0476e35e6e275db5
---

# act: watch

a public entity to a watched identity, with its monitor armed

[figure: The caller sends WatchInput to /v1/act/watch. The platform returns a card whose body is WatchedIdentity.]

<span class="op-method">POST</span><span class="op-path">/v1/act/watch</span>

Watch an identity. The call needs the brand rung under a token with the act grant, and it is served by the platform.

The route takes [WatchInput](/concepts/watchinput) and returns a card whose body is [WatchedIdentity](/concepts/watchedidentity).



## Request body
The request body is [WatchInput](/concepts/watchinput).



| field | type | required | note |
|---|---|---|---|
| `entity` | `id` | yes |  |



## Response
The route returns a card whose body is [WatchedIdentity](/concepts/watchedidentity). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the brand rung and a token with the act grant. The platform serves this route.

## Example
The example sends the smallest body that WatchInput allows. The build validates it against the schema of WatchInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/act/watch \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "entity": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.act.watch({
    "entity": "…"
  });
// answer.body is a WatchedIdentity. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/act/watch",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "entity": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/act/watch")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&WatchInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.act.watch` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/WatchedIdentity`. The [tool's page](/reference/tools/si-act-watch) describes it.


---
title: "act: watch site"
description: "a `WatchSiteInput` to the watch, ready or not ready; for a preview, the pages it would read and the changes it would have raised over the window"
section: reference
address: /reference/act/watch_site
contract: 0476e35e6e275db5
---

# act: watch site

a `WatchSiteInput` to the watch, ready or not ready; for a preview, the pages it would read and the changes it would have raised over the window

[figure: The caller sends WatchSiteInput to /v1/act/watch_site. The platform returns a card whose body is SiteWatch.]

<span class="op-method">POST</span><span class="op-path">/v1/act/watch_site</span>

Watch a site. The call needs the brand rung under a token with the act grant, and it is served by the platform.

The route takes [WatchSiteInput](/concepts/watchsiteinput) and returns a card whose body is [SiteWatch](/concepts/sitewatch).



## Request body
The request body is [WatchSiteInput](/concepts/watchsiteinput).



| field | type | required | note |
|---|---|---|---|
| `watch` | [SiteWatch](/concepts/sitewatch) | yes |  |
| `flow` | `one of write \| preview \| arm \| disarm` | yes |  |



## Response
The route returns a card whose body is [SiteWatch](/concepts/sitewatch). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the brand rung and a token with the act grant. The platform serves this route.

## Example
The example sends the smallest body that WatchSiteInput allows. The build validates it against the schema of WatchSiteInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/act/watch_site \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "watch": { "site": "…", "page_patterns": [], "use_sitemap": false, "cadence": "…", "conditions": { "tree": { "form": "group" }, "population": "…", "tree_hash": "…", "register_hash": "…", "compiler_version": "…", "comparator_versions": {} }, "channels": [], "state": { "ready": false, "since": "…" } }, "flow": "write" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.act.watch_site({
    "watch": {
      "site": "…",
      "page_patterns": [],
      "use_sitemap": false,
      "cadence": "…",
      "conditions": {
        "tree": {
          "form": "group"
        },
        "population": "…",
        "tree_hash": "…",
        "register_hash": "…",
        "compiler_version": "…",
        "comparator_versions": {}
      },
      "channels": [],
      "state": {
        "ready": false,
        "since": "…"
      }
    },
    "flow": "write"
  });
// answer.body is a SiteWatch. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/act/watch_site",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "watch": {
        "site": "…",
        "page_patterns": [],
        "use_sitemap": false,
        "cadence": "…",
        "conditions": {
          "tree": {
            "form": "group"
          },
          "population": "…",
          "tree_hash": "…",
          "register_hash": "…",
          "compiler_version": "…",
          "comparator_versions": {}
        },
        "channels": [],
        "state": {
          "ready": false,
          "since": "…"
        }
      },
      "flow": "write"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/act/watch_site")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&WatchSiteInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.act.watch_site` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/SiteWatch`. The [tool's page](/reference/tools/si-act-watch_site) describes it.


---
title: "act: webhook"
description: "the address, what to be told about, and a secret to sign with to the row"
section: reference
address: /reference/act/webhook
contract: 0476e35e6e275db5
---

# act: webhook

the address, what to be told about, and a secret to sign with to the row

[figure: The caller sends WebhookInput to /v1/act/webhook. The platform returns a card whose body is Telling.]

<span class="op-method">POST</span><span class="op-path">/v1/act/webhook</span>

Register an address to be told at. The call needs the tenant rung under a token with the act grant, and it is served by the platform.

The route takes [WebhookInput](/concepts/webhookinput) and returns a card whose body is [Telling](/concepts/telling).



## Request body
The request body is [WebhookInput](/concepts/webhookinput).



| field | type | required | note |
|---|---|---|---|
| `telling` | [Telling](/concepts/telling) | yes |  |



## Response
The route returns a card whose body is [Telling](/concepts/telling). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the tenant rung and a token with the act grant. The platform serves this route.

## Example
The example sends the smallest body that WebhookInput allows. The build validates it against the schema of WebhookInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/act/webhook \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "telling": { "tenant": "…", "address": "…", "kinds": [], "secret": "…", "tries_bound": 0, "failed_calls": [] } }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.act.webhook({
    "telling": {
      "tenant": "…",
      "address": "…",
      "kinds": [],
      "secret": "…",
      "tries_bound": 0,
      "failed_calls": []
    }
  });
// answer.body is a Telling. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/act/webhook",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "telling": {
        "tenant": "…",
        "address": "…",
        "kinds": [],
        "secret": "…",
        "tries_bound": 0,
        "failed_calls": []
      }
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/act/webhook")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&WebhookInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.act.webhook` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Telling`. The [tool's page](/reference/tools/si-act-webhook) describes it.


---
title: "act: weigh"
description: "a hypothesis, and a fact or a test's reading to the hypothesis with the evidence attached and its standing recomputed against its bar"
section: reference
address: /reference/act/weigh
contract: 0476e35e6e275db5
---

# act: weigh

a hypothesis, and a fact or a test's reading to the hypothesis with the evidence attached and its standing recomputed against its bar

[figure: The caller sends WeighInput to /v1/act/weigh. The platform returns a card whose body is Hypothesis.]

<span class="op-method">POST</span><span class="op-path">/v1/act/weigh</span>

Weigh a claim. The call needs the strategy rung under a token with the act grant, and it is served by either, by the size bound.

The route takes [WeighInput](/concepts/weighinput) and returns a card whose body is [Hypothesis](/concepts/hypothesis).



## Request body
The request body is [WeighInput](/concepts/weighinput).



| field | type | required | note |
|---|---|---|---|
| `hypothesis` | `id` | yes |  |
| `for` | [EvidenceRef](/concepts/evidenceref) | no |  |
| `against` | [EvidenceRef](/concepts/evidenceref) | no |  |



## Response
The route returns a card whose body is [Hypothesis](/concepts/hypothesis). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the strategy rung and a token with the act grant. The platform or the desktop app serves this route.

## Example
The example sends the smallest body that WeighInput allows. The build validates it against the schema of WeighInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/act/weigh \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "hypothesis": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.act.weigh({
    "hypothesis": "…"
  });
// answer.body is a Hypothesis. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/act/weigh",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "hypothesis": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/act/weigh")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&WeighInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.act.weigh` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Hypothesis`. The [tool's page](/reference/tools/si-act-weigh) describes it.


---
title: "act: withdraw"
description: "a publishing to the publishing, withdrawn"
section: reference
address: /reference/act/withdraw
contract: 0476e35e6e275db5
---

# act: withdraw

a publishing to the publishing, withdrawn

[figure: The caller sends WithdrawInput to /v1/act/withdraw. The platform returns a card whose body is Publishing.]

<span class="op-method">POST</span><span class="op-path">/v1/act/withdraw</span>

Withdraw. The call needs the brand rung under a token with the act grant, and it is served by the platform.

The route takes [WithdrawInput](/concepts/withdrawinput) and returns a card whose body is [Publishing](/concepts/publishing).



## Request body
The request body is [WithdrawInput](/concepts/withdrawinput).



| field | type | required | note |
|---|---|---|---|
| `publishing` | `id` | yes |  |
| `reason` | `text` | yes |  |



## Response
The route returns a card whose body is [Publishing](/concepts/publishing). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the brand rung and a token with the act grant. The platform serves this route.

## Example
The example sends the smallest body that WithdrawInput allows. The build validates it against the schema of WithdrawInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/act/withdraw \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "publishing": "…", "reason": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.act.withdraw({
    "publishing": "…",
    "reason": "…"
  });
// answer.body is a Publishing. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/act/withdraw",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "publishing": "…",
      "reason": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/act/withdraw")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&WithdrawInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.act.withdraw` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Publishing`. The [tool's page](/reference/tools/si-act-withdraw) describes it.


---
title: "act: workflow"
description: "its steps and what starts it to the workflow, and for a preview what it would have done over history, acting on nothing"
section: reference
address: /reference/act/workflow
contract: 0476e35e6e275db5
---

# act: workflow

its steps and what starts it to the workflow, and for a preview what it would have done over history, acting on nothing

[figure: The caller sends WorkflowInput to /v1/act/workflow. The platform returns a card whose body is WorkflowAnswer.]

<span class="op-method">POST</span><span class="op-path">/v1/act/workflow</span>

Write, preview and arm a workflow. The call needs the strategy rung under a token with the act grant, and it is served by the platform.

The route takes [WorkflowInput](/concepts/workflowinput) and returns a card whose body is [WorkflowAnswer](/concepts/workflowanswer).



## Request body
The request body is [WorkflowInput](/concepts/workflowinput).



| field | type | required | note |
|---|---|---|---|
| `workflow` | [Workflow](/concepts/workflow) | yes |  |
| `do` | `one of write \| preview \| arm` | yes |  |



## Response
The route returns a card whose body is [WorkflowAnswer](/concepts/workflowanswer). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the strategy rung and a token with the act grant. The platform serves this route.

## Example
The example sends the smallest body that WorkflowInput allows. The build validates it against the schema of WorkflowInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/act/workflow \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "workflow": { "name": "…", "starts_on": "a match", "steps": [], "strategy": "…", "state": { "ready": false, "since": "…" } }, "do": "write" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.act.workflow({
    "workflow": {
      "name": "…",
      "starts_on": "a match",
      "steps": [],
      "strategy": "…",
      "state": {
        "ready": false,
        "since": "…"
      }
    },
    "do": "write"
  });
// answer.body is a WorkflowAnswer. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/act/workflow",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "workflow": {
        "name": "…",
        "starts_on": "a match",
        "steps": [],
        "strategy": "…",
        "state": {
          "ready": false,
          "since": "…"
        }
      },
      "do": "write"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/act/workflow")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&WorkflowInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.act.workflow` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/WorkflowAnswer`. The [tool's page](/reference/tools/si-act-workflow) describes it.


---
title: "work: backfill"
description: "a source, an access method, a window, a plane to the job; then partitions carrying the window"
section: reference
address: /reference/work/backfill
contract: 0476e35e6e275db5
---

# work: backfill

a source, an access method, a window, a plane to the job; then partitions carrying the window

[figure: The caller sends BackfillInput to /v1/work/backfill. The platform returns a card whose body is Job.]

<span class="op-method">POST</span><span class="op-path">/v1/work/backfill</span><span class="op-note">a task, 202</span>

Run a backfill. The call needs the brand rung under a token with the work grant, and it is served by the platform.

The route takes [BackfillInput](/concepts/backfillinput) and returns a card whose body is [Job](/concepts/job).



## Request body
The request body is [BackfillInput](/concepts/backfillinput).



| field | type | required | note |
|---|---|---|---|
| `source` | `id` | yes |  |
| `access_method` | `id` | yes |  |
| `window` | [Window](/concepts/window) | yes |  |
| `plane` | [Plane](/concepts/plane) | yes |  |
| `reading` | `text` | no | the hash of the procedure reading the backfill runs over, filled by the platform from the newest reading of the source through the way's connector; a caller leaves it empty |



## Response
The route returns a card whose body is [Job](/concepts/job). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true. This route runs as a long step and returns a task with status 202. `POST /v1/work/status` returns the task's progress, and `POST /v1/work/cancel` stops the task.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the brand rung and a token with the work grant. The platform serves this route.

## Example
The example sends the smallest body that BackfillInput allows. The build validates it against the schema of BackfillInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/work/backfill \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "source": "…", "access_method": "…", "window": { "from": "…", "to": "…" }, "plane": { "plane": "shared" } }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.work.backfill({
    "source": "…",
    "access_method": "…",
    "window": {
      "from": "…",
      "to": "…"
    },
    "plane": {
      "plane": "shared"
    }
  });
// answer.body is a Job. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/work/backfill",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "source": "…",
      "access_method": "…",
      "window": {
        "from": "…",
        "to": "…"
      },
      "plane": {
        "plane": "shared"
      }
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/work/backfill")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&BackfillInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.work.backfill` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Job`. The [tool's page](/reference/tools/si-work-backfill) describes it.


---
title: "work: browse open"
description: "a `BrowseOpenInput` to the session, opened, with its live view"
section: reference
address: /reference/work/browse_open
contract: 0476e35e6e275db5
---

# work: browse open

a `BrowseOpenInput` to the session, opened, with its live view

[figure: The caller sends BrowseOpenInput to /v1/work/browse_open. The platform returns a card whose body is BrowsingSession.]

<span class="op-method">POST</span><span class="op-path">/v1/work/browse_open</span><span class="op-note">a task, 202</span>

Open a browsing session. The call needs the strategy rung under a token with the work grant, and it is served by either, by the size bound.

The route takes [BrowseOpenInput](/concepts/browseopeninput) and returns a card whose body is [BrowsingSession](/concepts/browsingsession).



## Request body
The request body is [BrowseOpenInput](/concepts/browseopeninput).



| field | type | required | note |
|---|---|---|---|
| `strategy` | `id` | no |  |
| `identity` | `id` | no |  |
| `proxy_policy` | [ProxyPolicy](/concepts/proxypolicy) | no |  |
| `filter` | [ResourceFilter](/concepts/resourcefilter) | no |  |
| `live_view` | `bool` | yes |  |



## Response
The route returns a card whose body is [BrowsingSession](/concepts/browsingsession). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true. This route runs as a long step and returns a task with status 202. `POST /v1/work/status` returns the task's progress, and `POST /v1/work/cancel` stops the task.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the strategy rung and a token with the work grant. The platform or the desktop app serves this route.

## Example
The example sends the smallest body that BrowseOpenInput allows. The build validates it against the schema of BrowseOpenInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/work/browse_open \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "live_view": false }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.work.browse_open({
    "live_view": false
  });
// answer.body is a BrowsingSession. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/work/browse_open",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "live_view": false
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/work/browse_open")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&BrowseOpenInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.work.browse_open` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/BrowsingSession`. The [tool's page](/reference/tools/si-work-browse_open) describes it.


---
title: "work: browse take over"
description: "a `BrowseTakeOverInput` to the session, driven by the person or handed back"
section: reference
address: /reference/work/browse_take_over
contract: 0476e35e6e275db5
---

# work: browse take over

a `BrowseTakeOverInput` to the session, driven by the person or handed back

[figure: The caller sends BrowseTakeOverInput to /v1/work/browse_take_over. The platform returns a card whose body is BrowsingSession.]

<span class="op-method">POST</span><span class="op-path">/v1/work/browse_take_over</span>

Take over, or hand back, a browsing session. The call needs the strategy rung under a token with the work grant, and it is served by either, by the size bound.

The route takes [BrowseTakeOverInput](/concepts/browsetakeoverinput) and returns a card whose body is [BrowsingSession](/concepts/browsingsession).



## Request body
The request body is [BrowseTakeOverInput](/concepts/browsetakeoverinput).



| field | type | required | note |
|---|---|---|---|
| `session` | `id` | yes |  |
| `hand_back` | `bool` | yes |  |



## Response
The route returns a card whose body is [BrowsingSession](/concepts/browsingsession). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the strategy rung and a token with the work grant. The platform or the desktop app serves this route.

## Example
The example sends the smallest body that BrowseTakeOverInput allows. The build validates it against the schema of BrowseTakeOverInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/work/browse_take_over \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "session": "…", "hand_back": false }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.work.browse_take_over({
    "session": "…",
    "hand_back": false
  });
// answer.body is a BrowsingSession. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/work/browse_take_over",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "session": "…",
      "hand_back": false
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/work/browse_take_over")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&BrowseTakeOverInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.work.browse_take_over` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/BrowsingSession`. The [tool's page](/reference/tools/si-work-browse_take_over) describes it.


---
title: "work: build facet"
description: "a facet kind, a seed (a predicate, a list of communities, or a place from the gazetteer), the scope, and the positive and negative controls to the facet's register with every candidate kept or dropped and its reason in words, its people, its pairs and its trend, and the facet not ready until its calibration is read"
section: reference
address: /reference/work/build_facet
contract: 0476e35e6e275db5
---

# work: build facet

a facet kind, a seed (a predicate, a list of communities, or a place from the gazetteer), the scope, and the positive and negative controls to the facet's register with every candidate kept or dropped and its reason in words, its people, its pairs and its trend, and the facet not ready until its calibration is read

[figure: The caller sends BuildFacetInput to /v1/work/build_facet. The platform returns a card whose body is Facet.]

<span class="op-method">POST</span><span class="op-path">/v1/work/build_facet</span><span class="op-note">a task, 202</span>

Build a facet. The call needs the strategy rung under a token with the work grant, and it is served by either, by the size bound.

The route takes [BuildFacetInput](/concepts/buildfacetinput) and returns a card whose body is [Facet](/concepts/facet).



## Request body
The request body is [BuildFacetInput](/concepts/buildfacetinput).



| field | type | required | note |
|---|---|---|---|
| `facet_kind` | [FacetKind](/concepts/facetkind) | yes |  |
| `seed` | `text` | yes |  |
| `again` | `bool` | no | when true, the same seed is built again as new work, for a presence that changed since the last build; without it the same seed under the same measure is the same work and returns the run already made |
| `asked_again_at` | `time` | no | set by the tool from the ask, so the run's key differs; never typed by hand |
| `scope` | [Scope](/concepts/scope) | yes |  |



## Response
The route returns a card whose body is [Facet](/concepts/facet). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true. This route runs as a long step and returns a task with status 202. `POST /v1/work/status` returns the task's progress, and `POST /v1/work/cancel` stops the task.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the strategy rung and a token with the work grant. The platform or the desktop app serves this route.

## Example
The example sends the smallest body that BuildFacetInput allows. The build validates it against the schema of BuildFacetInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/work/build_facet \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "facet_kind": "…", "seed": "…", "scope": { "level": "shared" } }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.work.build_facet({
    "facet_kind": "…",
    "seed": "…",
    "scope": {
      "level": "shared"
    }
  });
// answer.body is a Facet. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/work/build_facet",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "facet_kind": "…",
      "seed": "…",
      "scope": {
        "level": "shared"
      }
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/work/build_facet")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&BuildFacetInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.work.build_facet` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Facet`. The [tool's page](/reference/tools/si-work-build_facet) describes it.


---
title: "work: cancel"
description: "the preview to nothing"
section: reference
address: /reference/work/cancel
contract: 0476e35e6e275db5
---

# work: cancel

the preview to nothing

[figure: The caller sends CancelInput to /v1/work/cancel. The platform returns a card whose body is Nothing.]

<span class="op-method">POST</span><span class="op-path">/v1/work/cancel</span>

Cancel a preview. The call needs the strategy rung under a token with the work grant, and it is served by either, by the size bound.

The route takes [CancelInput](/concepts/cancelinput) and returns a card whose body is [Nothing](/concepts/nothing).



## Request body
The request body is [CancelInput](/concepts/cancelinput).



| field | type | required | note |
|---|---|---|---|
| `task` | `id` | yes |  |



## Response
The route returns a card whose body is [Nothing](/concepts/nothing). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the strategy rung and a token with the work grant. The platform or the desktop app serves this route.

## Example
The example sends the smallest body that CancelInput allows. The build validates it against the schema of CancelInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/work/cancel \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "task": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.work.cancel({
    "task": "…"
  });
// answer.body is a Nothing. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/work/cancel",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "task": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/work/cancel")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&CancelInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.work.cancel` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Nothing`. The [tool's page](/reference/tools/si-work-cancel) describes it.


---
title: "work: download set"
description: "a `DownloadInput` to `DownloadJob` rows, one per file"
section: reference
address: /reference/work/download_set
contract: 0476e35e6e275db5
---

# work: download set

a `DownloadInput` to `DownloadJob` rows, one per file

[figure: The caller sends DownloadSetInput to /v1/work/download_set. The platform returns a card whose body is [DownloadJob].]

<span class="op-method">POST</span><span class="op-path">/v1/work/download_set</span><span class="op-note">a task, 202</span>

Download files. The call needs the strategy rung under a token with the work grant, and it is served by either, by the size bound.

The route takes [DownloadSetInput](/concepts/downloadsetinput) and returns a card whose body is [DownloadJob](/concepts/downloadjob).



## Request body
The request body is [DownloadSetInput](/concepts/downloadsetinput).



| field | type | required | note |
|---|---|---|---|
| `addresses` | `[text]` | yes |  |
| `session` | `id` | no | the browsing session whose cookies serve |
| `identity` | `id` | no |  |
| `filter` | [ResourceFilter](/concepts/resourcefilter) | yes |  |
| `destination` | `one of bronze \| the workspace` | yes |  |



## Response
The route returns a card whose body is [DownloadJob](/concepts/downloadjob). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true. This route runs as a long step and returns a task with status 202. `POST /v1/work/status` returns the task's progress, and `POST /v1/work/cancel` stops the task.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the strategy rung and a token with the work grant. The platform or the desktop app serves this route.

## Example
The example sends the smallest body that DownloadSetInput allows. The build validates it against the schema of DownloadSetInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/work/download_set \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "addresses": [], "filter": { "allow_types": [], "deny_types": [], "allow_patterns": [], "deny_patterns": [], "render": "static" }, "destination": "bronze" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.work.download_set({
    "addresses": [],
    "filter": {
      "allow_types": [],
      "deny_types": [],
      "allow_patterns": [],
      "deny_patterns": [],
      "render": "static"
    },
    "destination": "bronze"
  });
// answer.body is a [DownloadJob]. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/work/download_set",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "addresses": [],
      "filter": {
        "allow_types": [],
        "deny_types": [],
        "allow_patterns": [],
        "deny_patterns": [],
        "render": "static"
      },
      "destination": "bronze"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/work/download_set")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&DownloadSetInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.work.download_set` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/DownloadJob`. The [tool's page](/reference/tools/si-work-download_set) describes it.


---
title: "work: download set control"
description: "a `DownloadControlInput` to the jobs in their new place"
section: reference
address: /reference/work/download_set_control
contract: 0476e35e6e275db5
---

# work: download set control

a `DownloadControlInput` to the jobs in their new place

[figure: The caller sends DownloadControlInput to /v1/work/download_set_control. The platform returns a card whose body is [DownloadJob].]

<span class="op-method">POST</span><span class="op-path">/v1/work/download_set_control</span>

Pause, resume or cancel a download. The call needs the strategy rung under a token with the work grant, and it is served by either, by the size bound.

The route takes [DownloadControlInput](/concepts/downloadcontrolinput) and returns a card whose body is [DownloadJob](/concepts/downloadjob).



## Request body
The request body is [DownloadControlInput](/concepts/downloadcontrolinput).



| field | type | required | note |
|---|---|---|---|
| `job` | `id` | no |  |
| `set` | `id` | no |  |
| `control` | `one of pause \| resume \| cancel` | yes |  |



## Response
The route returns a card whose body is [DownloadJob](/concepts/downloadjob). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the strategy rung and a token with the work grant. The platform or the desktop app serves this route.

## Example
The example sends the smallest body that DownloadControlInput allows. The build validates it against the schema of DownloadControlInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/work/download_set_control \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "control": "pause" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.work.download_set_control({
    "control": "pause"
  });
// answer.body is a [DownloadJob]. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/work/download_set_control",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "control": "pause"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/work/download_set_control")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&DownloadControlInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.work.download_set_control` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/DownloadJob`. The [tool's page](/reference/tools/si-work-download_set_control) describes it.


---
title: "work: lay strategy"
description: "Lays one strategy on one twin, with the bounds of the run to The call returns the simulation whose interventions are the strategy's armed plays, then the frame"
section: reference
address: /reference/work/lay_strategy
contract: 0476e35e6e275db5
---

# work: lay strategy

Lays one strategy on one twin, with the bounds of the run to The call returns the simulation whose interventions are the strategy's armed plays, then the frame

[figure: The caller sends LayStrategyInput to /v1/work/lay_strategy. The platform returns a card whose body is MarketSimulation.]

<span class="op-method">POST</span><span class="op-path">/v1/work/lay_strategy</span><span class="op-note">a task, 202</span>

Lay a strategy on a twin. The call needs the strategy rung under a token with the work grant, and it is served by the platform.

The route takes [LayStrategyInput](/concepts/laystrategyinput) and returns a card whose body is [MarketSimulation](/concepts/marketsimulation).



## Request body
The request body is [LayStrategyInput](/concepts/laystrategyinput).



| field | type | required | note |
|---|---|---|---|
| `twin` | `id` | yes |  |
| `strategy` | `id` | yes |  |
| `horizon` | `duration` | no |  |
| `samples` | `count` | no |  |
| `seed` | `count` | no |  |



## Response
The route returns a card whose body is [MarketSimulation](/concepts/marketsimulation). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true. This route runs as a long step and returns a task with status 202. `POST /v1/work/status` returns the task's progress, and `POST /v1/work/cancel` stops the task.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the strategy rung and a token with the work grant. The platform serves this route.

## Example
The example sends the smallest body that LayStrategyInput allows. The build validates it against the schema of LayStrategyInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/work/lay_strategy \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "twin": "…", "strategy": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.work.lay_strategy({
    "twin": "…",
    "strategy": "…"
  });
// answer.body is a MarketSimulation. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/work/lay_strategy",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "twin": "…",
      "strategy": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/work/lay_strategy")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&LayStrategyInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.work.lay_strategy` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/MarketSimulation`. The [tool's page](/reference/tools/si-work-lay_strategy) describes it.


---
title: "work: mine"
description: "the caller to every run the caller started that is still running, each with what it has done, whether it may be stopped, and the tool that stops it"
section: reference
address: /reference/work/mine
contract: 0476e35e6e275db5
---

# work: mine

the caller to every run the caller started that is still running, each with what it has done, whether it may be stopped, and the tool that stops it

[figure: The caller sends Nothing to /v1/work/mine. The platform returns a card whose body is MyWork.]

<span class="op-method">POST</span><span class="op-path">/v1/work/mine</span>

My running work. The call needs the user rung under a token with the work grant, and it is served by either, by the size bound.

The route takes an empty body and returns a card whose body is [MyWork](/concepts/mywork).



## Request body
The request body is empty.



## Response
The route returns a card whose body is [MyWork](/concepts/mywork). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the user rung and a token with the work grant. The platform or the desktop app serves this route.

## Example
The example sends an empty body.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/work/mine \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{}'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.work.mine({});
// answer.body is a MyWork. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/work/mine",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={}).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/work/mine")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&()).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.work.mine` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/MyWork`. The [tool's page](/reference/tools/si-work-mine) describes it.


---
title: "work: run procedure"
description: "the procedure and its inputs to a task"
section: reference
address: /reference/work/run_procedure
contract: 0476e35e6e275db5
---

# work: run procedure

the procedure and its inputs to a task

[figure: The caller sends RunProcedureInput to /v1/work/run_procedure. The platform returns a card whose body is Task.]

<span class="op-method">POST</span><span class="op-path">/v1/work/run_procedure</span><span class="op-note">a task, 202</span>

Follow a named procedure. The call needs the strategy rung under a token with the work grant, and it is served by either, by the size bound.

The route takes [RunProcedureInput](/concepts/runprocedureinput) and returns a card whose body is [Task](/concepts/task).



## Request body
The request body is [RunProcedureInput](/concepts/runprocedureinput).



| field | type | required | note |
|---|---|---|---|
| `procedure` | [NamedProcedure](/concepts/namedprocedure) | yes |  |
| `inputs` | `json` | no |  |



## Response
The route returns a card whose body is [Task](/concepts/task). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true. This route runs as a long step and returns a task with status 202. `POST /v1/work/status` returns the task's progress, and `POST /v1/work/cancel` stops the task.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the strategy rung and a token with the work grant. The platform or the desktop app serves this route.

## Example
The example sends the smallest body that RunProcedureInput allows. The build validates it against the schema of RunProcedureInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/work/run_procedure \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "procedure": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.work.run_procedure({
    "procedure": "…"
  });
// answer.body is a Task. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/work/run_procedure",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "procedure": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/work/run_procedure")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&RunProcedureInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.work.run_procedure` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Task`. The [tool's page](/reference/tools/si-work-run_procedure) describes it.


---
title: "work: search fit"
description: "Searches for product-market fit from one end: an offering looking for its markets, or a concept looking for a market to The call returns the search as work, then the frame that holds what it settled"
section: reference
address: /reference/work/search_fit
contract: 0476e35e6e275db5
---

# work: search fit

Searches for product-market fit from one end: an offering looking for its markets, or a concept looking for a market to The call returns the search as work, then the frame that holds what it settled

[figure: The caller sends FitSearchInput to /v1/work/search_fit. The platform returns a card whose body is FitSearch.]

<span class="op-method">POST</span><span class="op-path">/v1/work/search_fit</span><span class="op-note">a task, 202</span>

Search for product-market fit. The call needs the brand rung under a token with the work grant, and it is served by the platform.

The route takes [FitSearchInput](/concepts/fitsearchinput) and returns a card whose body is [FitSearch](/concepts/fitsearch).



## Request body
The request body is [FitSearchInput](/concepts/fitsearchinput).



| field | type | required | note |
|---|---|---|---|
| `brand` | `id` | yes |  |
| `from_end` | `one of an offering \| a concept` | yes |  |
| `offerings` | `[id]` | yes |  |
| `concept` | `text` | no |  |
| `candidate_verticals` | `[id]` | yes |  |



## Response
The route returns a card whose body is [FitSearch](/concepts/fitsearch). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true. This route runs as a long step and returns a task with status 202. `POST /v1/work/status` returns the task's progress, and `POST /v1/work/cancel` stops the task.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the brand rung and a token with the work grant. The platform serves this route.

## Example
The example sends the smallest body that FitSearchInput allows. The build validates it against the schema of FitSearchInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/work/search_fit \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "brand": "…", "from_end": "an offering", "offerings": [], "candidate_verticals": [] }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.work.search_fit({
    "brand": "…",
    "from_end": "an offering",
    "offerings": [],
    "candidate_verticals": []
  });
// answer.body is a FitSearch. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/work/search_fit",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "brand": "…",
      "from_end": "an offering",
      "offerings": [],
      "candidate_verticals": []
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/work/search_fit")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&FitSearchInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.work.search_fit` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/FitSearch`. The [tool's page](/reference/tools/si-work-search_fit) describes it.


---
title: "work: simulate market"
description: "Runs one systems model template over a market, with the interventions to try and the bounds of the run to The call returns the simulation as work, then the frame that holds what it reached"
section: reference
address: /reference/work/simulate_market
contract: 0476e35e6e275db5
---

# work: simulate market

Runs one systems model template over a market, with the interventions to try and the bounds of the run to The call returns the simulation as work, then the frame that holds what it reached

[figure: The caller sends MarketSimulationInput to /v1/work/simulate_market. The platform returns a card whose body is MarketSimulation.]

<span class="op-method">POST</span><span class="op-path">/v1/work/simulate_market</span><span class="op-note">a task, 202</span>

Simulate a market. The call needs the brand rung under a token with the work grant, and it is served by the platform.

The route takes [MarketSimulationInput](/concepts/marketsimulationinput) and returns a card whose body is [MarketSimulation](/concepts/marketsimulation).



## Request body
The request body is [MarketSimulationInput](/concepts/marketsimulationinput).



| field | type | required | note |
|---|---|---|---|
| `template` | [SystemsModelTemplate](/concepts/systemsmodeltemplate) | yes |  |
| `vertical` | `id` | yes |  |
| `segment` | `id` | no |  |
| `brand` | `id` | no |  |
| `interventions` | [Intervention](/concepts/intervention) | yes |  |
| `horizon` | `duration` | no | the template's when absent |
| `samples` | `count` | no | the parameter's when absent |
| `seed` | `count` | no |  |



## Response
The route returns a card whose body is [MarketSimulation](/concepts/marketsimulation). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true. This route runs as a long step and returns a task with status 202. `POST /v1/work/status` returns the task's progress, and `POST /v1/work/cancel` stops the task.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the brand rung and a token with the work grant. The platform serves this route.

## Example
The example sends the smallest body that MarketSimulationInput allows. The build validates it against the schema of MarketSimulationInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/work/simulate_market \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "template": "…", "vertical": "…", "interventions": [] }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.work.simulate_market({
    "template": "…",
    "vertical": "…",
    "interventions": []
  });
// answer.body is a MarketSimulation. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/work/simulate_market",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "template": "…",
      "vertical": "…",
      "interventions": []
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/work/simulate_market")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&MarketSimulationInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.work.simulate_market` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/MarketSimulation`. The [tool's page](/reference/tools/si-work-simulate_market) describes it.


---
title: "work: status"
description: "the task to its progress."
section: reference
address: /reference/work/status
contract: 0476e35e6e275db5
---

# work: status

the task to its progress.

[figure: The caller sends StatusInput to /v1/work/status. The platform returns a card whose body is Task.]

<span class="op-method">POST</span><span class="op-path">/v1/work/status</span>

Watch, answer or stop a task. The call needs the strategy rung under a token with the work grant, and it is served by either, by the size bound.

The route takes [StatusInput](/concepts/statusinput) and returns a card whose body is [Task](/concepts/task).



## Request body
The request body is [StatusInput](/concepts/statusinput).



| field | type | required | note |
|---|---|---|---|
| `task` | `id` | yes |  |
| `do` | `one of watch \| answer \| stop` | yes |  |
| `answer` | [TaskQuestion](/concepts/taskquestion) | no |  |



## Response
The route returns a card whose body is [Task](/concepts/task). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the strategy rung and a token with the work grant. The platform or the desktop app serves this route.

## Example
The example sends the smallest body that StatusInput allows. The build validates it against the schema of StatusInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/work/status \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "task": "…", "do": "watch" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.work.status({
    "task": "…",
    "do": "watch"
  });
// answer.body is a Task. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/work/status",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "task": "…",
      "do": "watch"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/work/status")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&StatusInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.work.status` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Task`. The [tool's page](/reference/tools/si-work-status) describes it.


---
title: "work: local procedure"
description: "a named procedure whose inputs are files in the workspace to a task run by the app with its steps in the app's own journal, resumable"
section: reference
address: /reference/work/local_procedure
contract: 0476e35e6e275db5
---

# work: local procedure

a named procedure whose inputs are files in the workspace to a task run by the app with its steps in the app's own journal, resumable

[figure: The caller sends LocalProcedureInput to /v1/work/local_procedure. The platform returns a card whose body is Task.]

<span class="op-method">POST</span><span class="op-path">/v1/work/local_procedure</span><span class="op-note">a task, 202</span>

From the local server's own. The call needs the strategy rung under a token with the work grant, and it is served by the installed app.

The route takes [LocalProcedureInput](/concepts/localprocedureinput) and returns a card whose body is [Task](/concepts/task).



## Request body
The request body is [LocalProcedureInput](/concepts/localprocedureinput).



| field | type | required | note |
|---|---|---|---|
| `procedure` | [NamedProcedure](/concepts/namedprocedure) | yes |  |
| `inputs` | `json` | no |  |



## Response
The route returns a card whose body is [Task](/concepts/task). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true. This route runs as a long step and returns a task with status 202. `POST /v1/work/status` returns the task's progress, and `POST /v1/work/cancel` stops the task.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the strategy rung and a token with the work grant. The desktop app serves this route.

## Example
The example sends the smallest body that LocalProcedureInput allows. The build validates it against the schema of LocalProcedureInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/work/local_procedure \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "procedure": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.work.local_procedure({
    "procedure": "…"
  });
// answer.body is a Task. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/work/local_procedure",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "procedure": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/work/local_procedure")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&LocalProcedureInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.work.local_procedure` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Task`. The [tool's page](/reference/tools/si-work-local_procedure) describes it.


---
title: "harness: delegate"
description: "words, in a strategy to response cards, as they come, and a task where the work goes on"
section: reference
address: /reference/harness/delegate
contract: 0476e35e6e275db5
---

# harness: delegate

words, in a strategy to response cards, as they come, and a task where the work goes on

[figure: The caller sends DelegateInput to /v1/harness/delegate. The platform returns a card whose body is Task.]

<span class="op-method">POST</span><span class="op-path">/v1/harness/delegate</span><span class="op-note">a task, 202</span>

Say something to the agent. The call needs the strategy rung under a token with the work grant, and it is served by the platform.

The route takes [DelegateInput](/concepts/delegateinput) and returns a card whose body is [Task](/concepts/task).



## Request body
The request body is [DelegateInput](/concepts/delegateinput).



| field | type | required | note |
|---|---|---|---|
| `words` | `text` | yes |  |
| `about` | [UnitRef](/concepts/unitref) | no |  |
| `strategy` | `id` | no |  |



## Response
The route returns a card whose body is [Task](/concepts/task). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true. This route runs as a long step and returns a task with status 202. `POST /v1/work/status` returns the task's progress, and `POST /v1/work/cancel` stops the task.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the strategy rung and a token with the work grant. The platform serves this route.

## Example
The example sends the smallest body that DelegateInput allows. The build validates it against the schema of DelegateInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/harness/delegate \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "words": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.harness.delegate({
    "words": "…"
  });
// answer.body is a Task. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/harness/delegate",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "words": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/harness/delegate")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&DelegateInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.harness.delegate` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Task`. The [tool's page](/reference/tools/si-harness-delegate) describes it.


---
title: "files: download"
description: "a file's pointer from a task or a document, and where in the workspace to put it to progress by bytes moved of bytes in all, then the path inside the workspace"
section: reference
address: /reference/files/download
contract: 0476e35e6e275db5
---

# files: download

a file's pointer from a task or a document, and where in the workspace to put it to progress by bytes moved of bytes in all, then the path inside the workspace

[figure: The caller sends DownloadInput to /v1/files/download. The platform returns a card whose body is FileTransfer.]

<span class="op-method">POST</span><span class="op-path">/v1/files/download</span><span class="op-note">a task, 202</span>

From the local server's own. The call needs the user rung under a token with the files grant, and it is served by the installed app.

The route takes [DownloadInput](/concepts/downloadinput) and returns a card whose body is [FileTransfer](/concepts/filetransfer).



## Request body
The request body is [DownloadInput](/concepts/downloadinput).



| field | type | required | note |
|---|---|---|---|
| `pointer` | `id` | yes |  |
| `into` | `text` | no |  |



## Response
The route returns a card whose body is [FileTransfer](/concepts/filetransfer). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true. This route runs as a long step and returns a task with status 202. `POST /v1/work/status` returns the task's progress, and `POST /v1/work/cancel` stops the task.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the user rung and a token with the files grant. The desktop app serves this route.

## Example
The example sends the smallest body that DownloadInput allows. The build validates it against the schema of DownloadInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/files/download \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "pointer": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.files.download({
    "pointer": "…"
  });
// answer.body is a FileTransfer. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/files/download",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "pointer": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/files/download")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&DownloadInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.files.download` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/FileTransfer`. The [tool's page](/reference/tools/si-files-download) describes it.


---
title: "files: upload"
description: "a path inside the workspace, and what the file is for to progress, then the pointer the platform kept"
section: reference
address: /reference/files/upload
contract: 0476e35e6e275db5
---

# files: upload

a path inside the workspace, and what the file is for to progress, then the pointer the platform kept

[figure: The caller sends UploadInput to /v1/files/upload. The platform returns a card whose body is FileTransfer.]

<span class="op-method">POST</span><span class="op-path">/v1/files/upload</span><span class="op-note">a task, 202</span>

From the local server's own. The call needs the user rung under a token with the files grant, and it is served by the installed app.

The route takes [UploadInput](/concepts/uploadinput) and returns a card whose body is [FileTransfer](/concepts/filetransfer).



## Request body
The request body is [UploadInput](/concepts/uploadinput).



| field | type | required | note |
|---|---|---|---|
| `path` | `text` | yes |  |
| `kind` | [UserProvidedContentKind](/concepts/userprovidedcontentkind) | yes |  |



## Response
The route returns a card whose body is [FileTransfer](/concepts/filetransfer). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true. This route runs as a long step and returns a task with status 202. `POST /v1/work/status` returns the task's progress, and `POST /v1/work/cancel` stops the task.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the user rung and a token with the files grant. The desktop app serves this route.

## Example
The example sends the smallest body that UploadInput allows. The build validates it against the schema of UploadInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/files/upload \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "path": "…", "kind": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.files.upload({
    "path": "…",
    "kind": "…"
  });
// answer.body is a FileTransfer. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/files/upload",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "path": "…",
      "kind": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/files/upload")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&UploadInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.files.upload` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/FileTransfer`. The [tool's page](/reference/tools/si-files-upload) describes it.


---
title: "files: list"
description: "a path inside the workspace, or nothing to the files with their sizes, kinds and when they were written"
section: reference
address: /reference/files/list
contract: 0476e35e6e275db5
---

# files: list

a path inside the workspace, or nothing to the files with their sizes, kinds and when they were written

[figure: The caller sends Nothing to /v1/files/list. The platform returns a card whose body is FileList.]

<span class="op-method">POST</span><span class="op-path">/v1/files/list</span>

From the local server's own. The call needs the user rung under a token with the files grant, and it is served by the installed app.

The route takes an empty body and returns a card whose body is [FileList](/concepts/filelist).



## Request body
The request body is empty.



## Response
The route returns a card whose body is [FileList](/concepts/filelist). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the user rung and a token with the files grant. The desktop app serves this route.

## Example
The example sends an empty body.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/files/list \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{}'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.files.list({});
// answer.body is a FileList. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/files/list",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={}).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/files/list")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&()).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.files.list` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/FileList`. The [tool's page](/reference/tools/si-files-list) describes it.


---
title: "files: workspace"
description: "nothing, or a folder to make the workspace to the workspace folder, and every act the app made in it on the ledger"
section: reference
address: /reference/files/workspace
contract: 0476e35e6e275db5
---

# files: workspace

nothing, or a folder to make the workspace to the workspace folder, and every act the app made in it on the ledger

[figure: The caller sends Nothing to /v1/files/workspace. The platform returns a card whose body is Workspace.]

<span class="op-method">POST</span><span class="op-path">/v1/files/workspace</span>

From the local server's own. The call needs the user rung under a token with the files grant, and it is served by the installed app.

The route takes an empty body and returns a card whose body is [Workspace](/concepts/workspace).



## Request body
The request body is empty.



## Response
The route returns a card whose body is [Workspace](/concepts/workspace). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the user rung and a token with the files grant. The desktop app serves this route.

## Example
The example sends an empty body.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/files/workspace \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{}'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.files.workspace({});
// answer.body is a Workspace. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/files/workspace",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={}).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/files/workspace")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&()).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.files.workspace` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Workspace`. The [tool's page](/reference/tools/si-files-workspace) describes it.


---
title: "economics: benchmarks"
description: "a driver, and a population or a buyer profile to the benchmarks that apply, each with its interval, population, period, source and what its rights allow"
section: reference
address: /reference/economics/benchmarks
contract: 0476e35e6e275db5
---

# economics: benchmarks

a driver, and a population or a buyer profile to the benchmarks that apply, each with its interval, population, period, source and what its rights allow

[figure: The caller sends BenchmarksInput to /v1/economics/benchmarks. The platform returns a card whose body is [Benchmark].]

<span class="op-method">POST</span><span class="op-path">/v1/economics/benchmarks</span>

Si.economics.benchmarks. The call needs the tenant rung under a token with the read grant, and it is served by either, by the size bound.

The route takes [BenchmarksInput](/concepts/benchmarksinput) and returns a card whose body is [Benchmark](/concepts/benchmark).



## Request body
The request body is [BenchmarksInput](/concepts/benchmarksinput).



| field | type | required | note |
|---|---|---|---|
| `driver` | [KindOfMeasure](/concepts/kindofmeasure) | yes |  |
| `kind_of_buyer` | `text` | no |  |



## Response
The route returns a card whose body is [Benchmark](/concepts/benchmark). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the tenant rung and a token with the read grant. The platform or the desktop app serves this route.

## Example
The example sends the smallest body that BenchmarksInput allows. The build validates it against the schema of BenchmarksInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/economics/benchmarks \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "driver": "…" }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.economics.benchmarks({
    "driver": "…"
  });
// answer.body is a [Benchmark]. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/economics/benchmarks",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "driver": "…"
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/economics/benchmarks")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&BenchmarksInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.economics.benchmarks` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/Benchmark`. The [tool's page](/reference/tools/si-economics-benchmarks) describes it.


---
title: "economics: estimate"
description: "`EstimateReturnInput`: the buyer (an entity, a lead, a buyer profile or a session), the offering or tier, the stated numbers, and whether to simulate to a `Card` whose body is a `FrameOfASale`"
section: reference
address: /reference/economics/estimate
contract: 0476e35e6e275db5
---

# economics: estimate

`EstimateReturnInput`: the buyer (an entity, a lead, a buyer profile or a session), the offering or tier, the stated numbers, and whether to simulate to a `Card` whose body is a `FrameOfASale`

[figure: The caller sends EstimateReturnInput to /v1/economics/estimate. The platform returns a card whose body is SaleFrame.]

<span class="op-method">POST</span><span class="op-path">/v1/economics/estimate</span>

Si.economics.estimate. The call needs the tenant rung under a token with the read grant, and it is served by either, by the size bound.

The route takes [EstimateReturnInput](/concepts/estimatereturninput) and returns a card whose body is [SaleFrame](/concepts/saleframe).



## Request body
The request body is [EstimateReturnInput](/concepts/estimatereturninput).



| field | type | required | note |
|---|---|---|---|
| `buyer` | [UnitRef](/concepts/unitref) | yes |  |
| `offering` | `id` | no |  |
| `tier` | `text` | no |  |
| `stated` | `{text:json}` | no | driver name to value, each written as a stated number before the estimate reads it |
| `simulate` | `bool` | yes |  |



## Response
The route returns a card whose body is [SaleFrame](/concepts/saleframe). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the tenant rung and a token with the read grant. The platform or the desktop app serves this route.

## Example
The example sends the smallest body that EstimateReturnInput allows. The build validates it against the schema of EstimateReturnInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/economics/estimate \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "buyer": { "id": "…", "kind": "…" }, "simulate": false }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.economics.estimate({
    "buyer": {
      "id": "…",
      "kind": "…"
    },
    "simulate": false
  });
// answer.body is a SaleFrame. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/economics/estimate",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "buyer": {
        "id": "…",
        "kind": "…"
      },
      "simulate": false
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/economics/estimate")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&EstimateReturnInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.economics.estimate` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/SaleFrame`. The [tool's page](/reference/tools/si-economics-estimate) describes it.


---
title: "economics: ladder"
description: "nothing, or a version to the price ladder in force with its study"
section: reference
address: /reference/economics/ladder
contract: 0476e35e6e275db5
---

# economics: ladder

nothing, or a version to the price ladder in force with its study

[figure: The caller sends LadderInput to /v1/economics/ladder. The platform returns a card whose body is PriceLadder.]

<span class="op-method">POST</span><span class="op-path">/v1/economics/ladder</span>

Si.economics.ladder. The call needs the tenant rung under a token with the read grant, and it is served by either, by the size bound.

The route takes [LadderInput](/concepts/ladderinput) and returns a card whose body is [PriceLadder](/concepts/priceladder).



## Request body
The request body is [LadderInput](/concepts/ladderinput).



| field | type | required | note |
|---|---|---|---|
| `version` | `count` | no |  |



## Response
The route returns a card whose body is [PriceLadder](/concepts/priceladder). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the tenant rung and a token with the read grant. The platform or the desktop app serves this route.

## Example
The example sends the smallest body that LadderInput allows. The build validates it against the schema of LadderInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/economics/ladder \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{}'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.economics.ladder({});
// answer.body is a PriceLadder. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/economics/ladder",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={}).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/economics/ladder")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&LadderInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.economics.ladder` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/PriceLadder`. The [tool's page](/reference/tools/si-economics-ladder) describes it.


---
title: "economics: models"
description: "a vertical, a segment or a buyer profile to the business models that apply, each with its readiness, its drivers and its outputs"
section: reference
address: /reference/economics/models
contract: 0476e35e6e275db5
---

# economics: models

a vertical, a segment or a buyer profile to the business models that apply, each with its readiness, its drivers and its outputs

[figure: The caller sends ModelsInput to /v1/economics/models. The platform returns a card whose body is [BusinessModel].]

<span class="op-method">POST</span><span class="op-path">/v1/economics/models</span>

Si.economics.models. The call needs the tenant rung under a token with the read grant, and it is served by either, by the size bound.

The route takes [ModelsInput](/concepts/modelsinput) and returns a card whose body is [BusinessModel](/concepts/businessmodel).



## Request body
The request body is [ModelsInput](/concepts/modelsinput).



| field | type | required | note |
|---|---|---|---|
| `vertical` | `id` | no |  |
| `segment` | `id` | no |  |
| `kind_of_buyer` | `text` | no | the buyer profile's name |



## Response
The route returns a card whose body is [BusinessModel](/concepts/businessmodel). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the tenant rung and a token with the read grant. The platform or the desktop app serves this route.

## Example
The example sends the smallest body that ModelsInput allows. The build validates it against the schema of ModelsInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/economics/models \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{}'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.economics.models({});
// answer.body is a [BusinessModel]. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/economics/models",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={}).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/economics/models")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&ModelsInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.economics.models` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/BusinessModel`. The [tool's page](/reference/tools/si-economics-models) describes it.


---
title: "economics: offer"
description: "`ReadingOfferedInput`: the buyer profile, the model, the drivers to ask to the reading offered, ready or not ready with the reason, and its page's address"
section: reference
address: /reference/economics/offer
contract: 0476e35e6e275db5
---

# economics: offer

`ReadingOfferedInput`: the buyer profile, the model, the drivers to ask to the reading offered, ready or not ready with the reason, and its page's address

[figure: The caller sends ReadingOfferedInput to /v1/economics/offer. The platform returns a card whose body is ReadingOffered.]

<span class="op-method">POST</span><span class="op-path">/v1/economics/offer</span>

Si.economics.offer. The call needs the brand rung under a token with the act grant, and it is served by the platform.

The route takes [ReadingOfferedInput](/concepts/readingofferedinput) and returns a card whose body is [ReadingOffered](/concepts/readingoffered).



## Request body
The request body is [ReadingOfferedInput](/concepts/readingofferedinput).



| field | type | required | note |
|---|---|---|---|
| `kind_of_buyer` | `id` | yes |  |
| `business_model` | `id` | yes |  |
| `asks` | [KindOfMeasure](/concepts/kindofmeasure) | yes |  |



## Response
The route returns a card whose body is [ReadingOffered](/concepts/readingoffered). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the brand rung and a token with the act grant. The platform serves this route.

## Example
The example sends the smallest body that ReadingOfferedInput allows. The build validates it against the schema of ReadingOfferedInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/economics/offer \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "kind_of_buyer": "…", "business_model": "…", "asks": [] }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.economics.offer({
    "kind_of_buyer": "…",
    "business_model": "…",
    "asks": []
  });
// answer.body is a ReadingOffered. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/economics/offer",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "kind_of_buyer": "…",
      "business_model": "…",
      "asks": []
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/economics/offer")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&ReadingOfferedInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.economics.offer` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/ReadingOffered`. The [tool's page](/reference/tools/si-economics-offer) describes it.


---
title: "economics: study"
description: "`PricingStudyInput`: the methods to run, the buyer profiles, the rivals' window to the study as a fact and its candidate ladders as a set of options"
section: reference
address: /reference/economics/study
contract: 0476e35e6e275db5
---

# economics: study

`PricingStudyInput`: the methods to run, the buyer profiles, the rivals' window to the study as a fact and its candidate ladders as a set of options

[figure: The caller sends PricingStudyInput to /v1/economics/study. The platform returns a card whose body is PricingStudy.]

<span class="op-method">POST</span><span class="op-path">/v1/economics/study</span><span class="op-note">a task, 202</span>

Si.economics.study. The call needs the platform rung under a token with the act grant, and it is served by the platform.

The route takes [PricingStudyInput](/concepts/pricingstudyinput) and returns a card whose body is [PricingStudy](/concepts/pricingstudy).



## Request body
The request body is [PricingStudyInput](/concepts/pricingstudyinput).



| field | type | required | note |
|---|---|---|---|
| `methods` | [Method](/concepts/method) | yes |  |
| `kinds_of_buyer` | `[id]` | yes |  |
| `window` | [Window](/concepts/window) | yes |  |



## Response
The route returns a card whose body is [PricingStudy](/concepts/pricingstudy). Every card ends with a foot that states the basis of each number, the scope of the call, and the time when the facts were true. This route runs as a long step and returns a task with status 202. `POST /v1/work/status` returns the task's progress, and `POST /v1/work/cancel` stops the task.

## Headers


| header | required | meaning |
|---|---|---|
| `Scale-Scope` | yes | the scope the call runs in: tenant/<id>, then /brand/<id>, then /strategy/<id> |
| `Scale-As-True-On` | no | the date the facts must have been true on; defaults to now |
| `Scale-As-Known-On` | no | the date the facts must have been known on; defaults to now |
| `Scale-Key` | no | for a change, the key made from the input; a repeat under the same key returns the unit held and writes nothing |



A caller needs the platform rung and a token with the act grant. The platform serves this route.

## Example
The example sends the smallest body that PricingStudyInput allows. The build validates it against the schema of PricingStudyInput.

<details class="wire"><summary>Example</summary>





```sh
curl -X POST https://api.scaleintelligence.co/v1/economics/study \
  -H "Scale-Key: $SCALE_KEY" -H "Scale-Scope: tenant/<id>" \
  -H "content-type: application/json" \
  -d '{ "methods": [], "kinds_of_buyer": [], "window": { "from": "…", "to": "…" } }'
```




```typescript
import { client } from "@scale/sdk";
const answer = await client.economics.study({
    "methods": [],
    "kinds_of_buyer": [],
    "window": {
      "from": "…",
      "to": "…"
    }
  });
// answer.body is a PricingStudy. answer.foot holds the basis, the scope and the time.
```




```python
import requests
answer = requests.post("https://api.scaleintelligence.co/v1/economics/study",
    headers={"Scale-Key": KEY, "Scale-Scope": "tenant/<id>"},
    json={
      "methods": [],
      "kinds_of_buyer": [],
      "window": {
        "from": "…",
        "to": "…"
      }
    }).json()
```




```rust
let answer: Card = client.post("https://api.scaleintelligence.co/v1/economics/study")
    .header("Scale-Key", key).header("Scale-Scope", "tenant/<id>")
    .json(&PricingStudyInput { /* the fields of the page */ }).send().await?.json().await?;
```




</details>

## MCP tool
The MCP tool `si.economics.study` takes the same input and returns the same card. The tool changes data and needs a grant. An MCP host that renders cards draws this card from `ui://scale-intelligence/cards/PricingStudy`. The [tool's page](/reference/tools/si-economics-study) describes it.


---
title: "tool si.act.act_through_connector"
description: "the installed connector, the kind, the arguments with their sources: a move, proposed or running by the grant's mode; then the source's own id for what was done."
section: reference
address: /reference/tools/si-act-act_through_connector
contract: 0476e35e6e275db5
---

# tool si.act.act_through_connector

the installed connector, the kind, the arguments with their sources: a move, proposed or running by the grant's mode; then the source's own id for what was done.

[figure: Over MCP, si.act.act_through_connector takes ActThroughConnectorInput and returns a card whose body is Move.]

a move, proposed or running by the grant's mode; then the source's own id for what was done. The call needs the act grant at the brand rung.



| | |
|---|---|
| input | [ActThroughConnectorInput](/concepts/actthroughconnectorinput) |
| result | a card whose body is [Move](/concepts/move) |
| read-only | no |
| destructive | yes |
| card address | `ui://scale-intelligence/cards/Move` |
| HTTP route | [`/v1/act/act_through_connector`](/reference/act/act_through_connector) |





| field | type | required | note |
|---|---|---|---|
| `installed_connector` | `id` | yes |  |
| `kind_of_action` | `id` | yes |  |
| `arguments` | `{text:json}` | yes |  |
| `argument_sources` | `{text:text}` | yes | the record by id, a definition, a person's own words |


---
title: "tool si.act.annotate"
description: "an `Annotation` with the target *an entity* and the entity's id, from the web shell, the desktop shell, the agent or the API; in the side panel the same type travels inside the page's reading: the fact the person stated, a claim or a connection, by its id and kind (`UnitRef`)."
section: reference
address: /reference/tools/si-act-annotate
contract: 0476e35e6e275db5
---

# tool si.act.annotate

an `Annotation` with the target *an entity* and the entity's id, from the web shell, the desktop shell, the agent or the API; in the side panel the same type travels inside the page's reading: the fact the person stated, a claim or a connection, by its id and kind (`UnitRef`).

[figure: Over MCP, si.act.annotate takes Annotation and returns a card whose body is UnitRef.]

the fact the person stated, a claim or a connection, by its id and kind (`UnitRef`). The call needs the act grant at the user rung.



| | |
|---|---|
| input | [Annotation](/concepts/annotation) |
| result | a card whose body is [UnitRef](/concepts/unitref) |
| read-only | no |
| destructive | yes |
| card address | `ui://scale-intelligence/cards/UnitRef` |
| HTTP route | [`/v1/act/annotate`](/reference/act/annotate) |





| field | type | required | note |
|---|---|---|---|
| `target` | `one of the page \| an item \| a contact \| a region \| an entity` | yes | an entity when the annotation is made on an entity's page or by the agent, with the entity in subject |
| `subject` | `id` | no | the entity the annotation is about when the target is an entity; absent on a page, whose subject the capture supplies |
| `said_in` | `one of the capture panel \| the web shell \| the desktop shell \| the agent \| the API` | no | the face the person said it in; absent means the capture panel |
| `item_field` | `text` | no | the list field the item belongs to |
| `item_key` | `text` | no | the item's own id, or its index |
| `contact` | `text` | no | the contact's namespace and normalised value, joined by a bar |
| `region_selector` | `text` | no | a selector path to the picked element |
| `region_text` | `text` | no | the picked element's visible text |
| `kind` | `one of a tag \| a relation \| a note \| a rival \| a fit \| a membership \| a kind of thing` | yes | a rival marks the subject as competing with one of the tenant's brands; a fit states it fits a kind of buyer; a membership places it in a facet, a vertical, a segment or a community; a kind of thing says what the subject is |
| `register` | `text` | no | the place of the record the unit was found in (kinds of buyer, brands, offerings, facets, verticals, concepts, segments, communities, entities) |
| `value` | `text` | yes | the tag's name, the relation's kind of connection or the person's own words for it, the note, or the kind of entity |
| `entity` | `id` | no | the unit of the record it points at; absent for a thing the record does not hold yet |
| `entity_name` | `text` | no | the unit's name, or the name of a new thing |
| `entity_kind` | `text` | no | the unit's kind, or the kind of entity the person set for a new thing |
| `role` | `text` | no | for a relation: the role the page's subject takes |
| `stated_at` | `time` | yes |  |


---
title: "tool si.act.arm_monitor"
description: "the monitor's version, and for arming the preview it was judged by: the monitor's new state."
section: reference
address: /reference/tools/si-act-arm_monitor
contract: 0476e35e6e275db5
---

# tool si.act.arm_monitor

the monitor's version, and for arming the preview it was judged by: the monitor's new state.

[figure: Over MCP, si.act.arm_monitor takes ArmMonitorInput and returns a card whose body is Monitor.]

the monitor's new state. The call needs the act grant at the strategy rung.



| | |
|---|---|
| input | [ArmMonitorInput](/concepts/armmonitorinput) |
| result | a card whose body is [Monitor](/concepts/monitor) |
| read-only | no |
| destructive | yes |
| card address | `ui://scale-intelligence/cards/Monitor` |
| HTTP route | [`/v1/act/arm_monitor`](/reference/act/arm_monitor) |





| field | type | required | note |
|---|---|---|---|
| `monitor` | `id` | yes |  |
| `version` | `count` | yes |  |
| `arm` | `bool` | yes |  |
| `preview` | `id` | no | required to arm |


---
title: "tool si.act.arm_play"
description: "a strategy, the play and its version, the goal it serves, and the share it is armed on with its holdout (a share under one makes the play an experiment): the armed play with its class proposed from the kind's usual class and the rivals' coverage, and the demand cells it raised."
section: reference
address: /reference/tools/si-act-arm_play
contract: 0476e35e6e275db5
---

# tool si.act.arm_play

a strategy, the play and its version, the goal it serves, and the share it is armed on with its holdout (a share under one makes the play an experiment): the armed play with its class proposed from the kind's usual class and the rivals' coverage, and the demand cells it raised.

[figure: Over MCP, si.act.arm_play takes ArmPlayInput and returns a card whose body is ArmPlayAnswer.]

the armed play with its class proposed from the kind's usual class and the rivals' coverage, and the demand cells it raised. The call needs the act grant at the strategy rung.



| | |
|---|---|
| input | [ArmPlayInput](/concepts/armplayinput) |
| result | a card whose body is [ArmPlayAnswer](/concepts/armplayanswer) |
| read-only | no |
| destructive | yes |
| card address | `ui://scale-intelligence/cards/ArmPlayAnswer` |
| HTTP route | [`/v1/act/arm_play`](/reference/act/arm_play) |





| field | type | required | note |
|---|---|---|---|
| `play` | `id` | yes |  |
| `strategy` | `id` | yes |  |
| `brand` | `id` | yes |  |
| `arm` | `bool` | yes |  |
| `share` | `share` | no | the share of the admitted members the arming admits; absent keeps the play's own |
| `holdout` | `share` | no | the share left alone at random, read as the effect's comparison; absent keeps the play's own |


---
title: "tool si.act.assign"
description: "Assigns one lead to one user by hand, or hands it on: The answer gives the assignment, with the person who made it as its reason."
section: reference
address: /reference/tools/si-act-assign
contract: 0476e35e6e275db5
---

# tool si.act.assign

Assigns one lead to one user by hand, or hands it on: The answer gives the assignment, with the person who made it as its reason.

[figure: Over MCP, si.act.assign takes AssignInput and returns a card whose body is LeadAssignment.]

The answer gives the assignment, with the person who made it as its reason. The call needs the act grant at the strategy rung.



| | |
|---|---|
| input | [AssignInput](/concepts/assigninput) |
| result | a card whose body is [LeadAssignment](/concepts/leadassignment) |
| read-only | no |
| destructive | yes |
| card address | `ui://scale-intelligence/cards/LeadAssignment` |
| HTTP route | [`/v1/act/assign`](/reference/act/assign) |





| field | type | required | note |
|---|---|---|---|
| `lead` | `id` | yes |  |
| `user` | `id` | yes |  |
| `reason` | `text` | yes |  |


---
title: "tool si.act.beat"
description: "what runs, and when: the beat."
section: reference
address: /reference/tools/si-act-beat
contract: 0476e35e6e275db5
---

# tool si.act.beat

what runs, and when: the beat.

[figure: Over MCP, si.act.beat takes BeatInput and returns a card whose body is Beat.]

the beat. The call needs the act grant at the strategy rung.



| | |
|---|---|
| input | [BeatInput](/concepts/beatinput) |
| result | a card whose body is [Beat](/concepts/beat) |
| read-only | no |
| destructive | yes |
| card address | `ui://scale-intelligence/cards/Beat` |
| HTTP route | [`/v1/act/beat`](/reference/act/beat) |





| field | type | required | note |
|---|---|---|---|
| `beat` | [Beat](/concepts/beat) | yes |  |


---
title: "tool si.act.bind_buyer"
description: "the kind, an offering or a segment, the weight, the mode: the binding, and the preview of the kind's members."
section: reference
address: /reference/tools/si-act-bind_buyer
contract: 0476e35e6e275db5
---

# tool si.act.bind_buyer

the kind, an offering or a segment, the weight, the mode: the binding, and the preview of the kind's members.

[figure: Over MCP, si.act.bind_buyer takes BindBuyerInput and returns a card whose body is BindBuyerAnswer.]

the binding, and the preview of the kind's members. The call needs the act grant at the brand rung.



| | |
|---|---|
| input | [BindBuyerInput](/concepts/bindbuyerinput) |
| result | a card whose body is [BindBuyerAnswer](/concepts/bindbuyeranswer) |
| read-only | no |
| destructive | yes |
| card address | `ui://scale-intelligence/cards/BindBuyerAnswer` |
| HTTP route | [`/v1/act/bind_buyer`](/reference/act/bind_buyer) |





| field | type | required | note |
|---|---|---|---|
| `kind_of_buyer` | `id` | yes |  |
| `bindings` | [Binding](/concepts/binding) | yes |  |
| `ladder` | `text` | no | the ladder the kind climbs, by its name, where the binding changes it; the ladder must be kept and ready |


---
title: "tool si.act.board"
description: "the board with its tiles: the board, ready, or not ready with the tile that could not be drawn."
section: reference
address: /reference/tools/si-act-board
contract: 0476e35e6e275db5
---

# tool si.act.board

the board with its tiles: the board, ready, or not ready with the tile that could not be drawn.

[figure: Over MCP, si.act.board takes BoardInput and returns a card whose body is Board.]

the board, ready, or not ready with the tile that could not be drawn. The call needs the act grant at the tenant rung.



| | |
|---|---|
| input | [BoardInput](/concepts/boardinput) |
| result | a card whose body is [Board](/concepts/board) |
| read-only | no |
| destructive | yes |
| card address | `ui://scale-intelligence/cards/Board` |
| HTTP route | [`/v1/act/board`](/reference/act/board) |





| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `audience` | `text` | yes |  |
| `tiles` | [Tile](/concepts/tile) | yes |  |
| `period` | [Window](/concepts/window) | yes |  |


---
title: "tool si.act.browse_step"
description: "a `BrowseStepInput`: the step's result: the accessibility tree, the text, the markdown, a screenshot's hash, or a download set."
section: reference
address: /reference/tools/si-act-browse_step
contract: 0476e35e6e275db5
---

# tool si.act.browse_step

a `BrowseStepInput`: the step's result: the accessibility tree, the text, the markdown, a screenshot's hash, or a download set.

[figure: Over MCP, si.act.browse_step takes BrowseStepInput and returns a card whose body is BrowsingStep.]

the step's result: the accessibility tree, the text, the markdown, a screenshot's hash, or a download set. The call needs the act grant at the strategy rung.



| | |
|---|---|
| input | [BrowseStepInput](/concepts/browsestepinput) |
| result | a card whose body is [BrowsingStep](/concepts/browsingstep) |
| read-only | no |
| destructive | yes |
| card address | `ui://scale-intelligence/cards/BrowsingStep` |
| HTTP route | [`/v1/act/browse_step`](/reference/act/browse_step) |





| field | type | required | note |
|---|---|---|---|
| `session` | `id` | yes |  |
| `step` | [BrowsingStep](/concepts/browsingstep) | yes |  |


---
title: "tool si.act.build_document"
description: "the document, the two dates, which default to now: the build, then the version, or not ready with every number that is missing."
section: reference
address: /reference/tools/si-act-build_document
contract: 0476e35e6e275db5
---

# tool si.act.build_document

the document, the two dates, which default to now: the build, then the version, or not ready with every number that is missing.

[figure: Over MCP, si.act.build_document takes BuildDocumentInput and returns a card whose body is Build.]

the build, then the version, or not ready with every number that is missing. The call needs the act grant at the brand rung.



| | |
|---|---|
| input | [BuildDocumentInput](/concepts/builddocumentinput) |
| result | a card whose body is [Build](/concepts/build) |
| read-only | no |
| destructive | yes |
| card address | `ui://scale-intelligence/cards/Build` |
| HTTP route | [`/v1/act/build_document`](/reference/act/build_document) |





| field | type | required | note |
|---|---|---|---|
| `document` | `id` | yes |  |


---
title: "tool si.act.capacity"
description: "Sets how many new leads one user can take in a period: The answer gives the new capacity, with how many the user holds and when it refills."
section: reference
address: /reference/tools/si-act-capacity
contract: 0476e35e6e275db5
---

# tool si.act.capacity

Sets how many new leads one user can take in a period: The answer gives the new capacity, with how many the user holds and when it refills.

[figure: Over MCP, si.act.capacity takes CapacityInput and returns a card whose body is Capacity.]

The answer gives the new capacity, with how many the user holds and when it refills. The call needs the act grant at the brand rung.



| | |
|---|---|
| input | [CapacityInput](/concepts/capacityinput) |
| result | a card whose body is [Capacity](/concepts/capacity) |
| read-only | no |
| destructive | yes |
| card address | `ui://scale-intelligence/cards/Capacity` |
| HTTP route | [`/v1/act/capacity`](/reference/act/capacity) |





| field | type | required | note |
|---|---|---|---|
| `user` | `id` | yes |  |
| `per_period` | `count` | yes |  |
| `period` | `duration` | yes |  |


---
title: "tool si.act.capture"
description: "the document, the network events, the address, the person's identity: the capture with its source objects and the cells credited."
section: reference
address: /reference/tools/si-act-capture
contract: 0476e35e6e275db5
---

# tool si.act.capture

the document, the network events, the address, the person's identity: the capture with its source objects and the cells credited.

[figure: Over MCP, si.act.capture takes CaptureInput and returns a card whose body is Capture.]

the capture with its source objects and the cells credited. The call needs the act grant at the user rung.



| | |
|---|---|
| input | [CaptureInput](/concepts/captureinput) |
| result | a card whose body is [Capture](/concepts/capture) |
| read-only | no |
| destructive | yes |
| card address | `ui://scale-intelligence/cards/Capture` |
| HTTP route | [`/v1/act/capture`](/reference/act/capture) |





| field | type | required | note |
|---|---|---|---|
| `address` | `text` | yes |  |
| `document` | `text` | yes |  |
| `network_events` | `[json]` | yes |  |
| `identity` | `id` | no |  |
| `scope` | `one of this item \| this thread \| this channel as shown \| this page \| this meeting \| my outbound message` | yes |  |
| `under` | `one of say-so \| rule` | yes |  |
| `rule` | `id` | no |  |
| `extension_version` | `text` | yes |  |
| `artefact_hash` | `hash` | yes |  |
| `selection` | `text` | no |  |


---
title: "tool si.act.capture_rule"
description: "the rule: the rule, ready or not ready with the reason."
section: reference
address: /reference/tools/si-act-capture_rule
contract: 0476e35e6e275db5
---

# tool si.act.capture_rule

the rule: the rule, ready or not ready with the reason.

[figure: Over MCP, si.act.capture_rule takes CaptureRuleInput and returns a card whose body is CaptureRule.]

the rule, ready or not ready with the reason. The call needs the act grant at the user rung.



| | |
|---|---|
| input | [CaptureRuleInput](/concepts/captureruleinput) |
| result | a card whose body is [CaptureRule](/concepts/capturerule) |
| read-only | no |
| destructive | yes |
| card address | `ui://scale-intelligence/cards/CaptureRule` |
| HTTP route | [`/v1/act/capture_rule`](/reference/act/capture_rule) |





| field | type | required | note |
|---|---|---|---|
| `platform` | `text` | yes |  |
| `mode` | `one of on my say-so \| on my own submit \| ask me on this platform \| every page I open \| never` | yes |  |
| `way` | [AccessMethod](/concepts/accessmethod) | no |  |
| `default_scope` | `one of this item \| this thread \| this channel as shown \| this page \| this meeting \| my outbound message` | yes |  |
| `never_captured` | `[text]` | yes | addresses or kinds |
| `redactions` | [RedactionRule](/concepts/redactionrule) | no | the person's own |
| `browser_grant` | `one of given \| not given \| not needed` | no | the browser's standing host permission for the platform as the extension found it when the rule was written: asked of the person for every page I open, and not needed for the other modes; absent when the rule is written from a surface that is not the browser |


---
title: "tool si.act.change_plan"
description: "the plan kind: the change as a proposal, and the provider's own page for payment."
section: reference
address: /reference/tools/si-act-change_plan
contract: 0476e35e6e275db5
---

# tool si.act.change_plan

the plan kind: the change as a proposal, and the provider's own page for payment.

[figure: Over MCP, si.act.change_plan takes ChangePlanInput and returns a card whose body is PlanChange.]

the change as a proposal, and the provider's own page for payment. The call needs the admin grant at the tenant rung.



| | |
|---|---|
| input | [ChangePlanInput](/concepts/changeplaninput) |
| result | a card whose body is [PlanChange](/concepts/planchange) |
| read-only | no |
| destructive | yes |
| card address | `ui://scale-intelligence/cards/PlanChange` |
| HTTP route | [`/v1/act/change_plan`](/reference/act/change_plan) |





| field | type | required | note |
|---|---|---|---|
| `plan_kind` | `one of trial \| paid \| internal` | yes |  |


---
title: "tool si.act.correct"
description: "the id of the wrong event, and the right facts: a correcting event."
section: reference
address: /reference/tools/si-act-correct
contract: 0476e35e6e275db5
---

# tool si.act.correct

the id of the wrong event, and the right facts: a correcting event.

[figure: Over MCP, si.act.correct takes CorrectInput and returns a card whose body is Event.]

a correcting event. The call needs the act grant at the strategy rung.



| | |
|---|---|
| input | [CorrectInput](/concepts/correctinput) |
| result | a card whose body is [Event](/concepts/event) |
| read-only | no |
| destructive | yes |
| card address | `ui://scale-intelligence/cards/Event` |
| HTTP route | [`/v1/act/correct`](/reference/act/correct) |





| field | type | required | note |
|---|---|---|---|
| `event` | `id` | yes |  |
| `correction` | [Event](/concepts/event) | yes |  |
| `why` | `text` | yes |  |


---
title: "tool si.act.crawl"
description: "a `ScrapeRequest` whose scope names the site's seeds, with sitemap-driven discovery on: the `ScrapeRun`, queued, or the run that already stands for the same template version and scope inside its freshness; every page lands as a capture through the one pipeline, and each page that could not be read is a gap with its…"
section: reference
address: /reference/tools/si-act-crawl
contract: 0476e35e6e275db5
---

# tool si.act.crawl

a `ScrapeRequest` whose scope names the site's seeds, with sitemap-driven discovery on: the `ScrapeRun`, queued, or the run that already stands for the same template version and scope inside its freshness; every page lands as a capture through the one pipeline, and each page that could not be read is a gap with its…

[figure: Over MCP, si.act.crawl takes ScrapeRequest and returns a card whose body is ScrapeRun.]

the `ScrapeRun`, queued, or the run that already stands for the same template version and scope inside its freshness; every page lands as a capture through the one pipeline, and each page that could not be read is a gap with its reason. The call needs the act grant at the brand rung.



| | |
|---|---|
| input | [ScrapeRequest](/concepts/scraperequest) |
| result | a card whose body is [ScrapeRun](/concepts/scraperun) |
| read-only | no |
| destructive | yes |
| card address | `ui://scale-intelligence/cards/ScrapeRun` |
| HTTP route | [`/v1/act/crawl`](/reference/act/crawl) |





| field | type | required | note |
|---|---|---|---|
| `template` | `id` | no | an extraction template; any of its parts may be overridden below |
| `scope` | [CrawlScope](/concepts/crawlscope) | no | required when no template |
| `fields` | [FieldSpec](/concepts/fieldspec) | no | declared selectors |
| `schema` | `json` | no | for the model-assisted reader, every value with its evidence span or refused |
| `source_object` | [SourceObject](/concepts/sourceobject) | yes | declared inline for one scrape, or a registered row |
| `mapping` | [Mapping](/concepts/mapping) | no |  |
| `filter` | [ResourceFilter](/concepts/resourcefilter) | yes |  |
| `as_identity` | `id` | no |  |
| `proxy_policy` | [ProxyPolicy](/concepts/proxypolicy) | no |  |
| `credit_cells` | `[id]` | no |  |
| `asked_by` | `text` | no | who asked for the run, as the caller's kind, or the crawler for an address a walk found; the beat takes what a person or the agent asked before the crawler's own discoveries, oldest first within each |


---
title: "tool si.act.decide_ask"
description: "the ask, by a user who may: the ask, approved or declined."
section: reference
address: /reference/tools/si-act-decide_ask
contract: 0476e35e6e275db5
---

# tool si.act.decide_ask

the ask, by a user who may: the ask, approved or declined.

[figure: Over MCP, si.act.decide_ask takes DecideAskInput and returns a card whose body is Ask.]

the ask, approved or declined. The call needs the act grant at the brand rung.



| | |
|---|---|
| input | [DecideAskInput](/concepts/decideaskinput) |
| result | a card whose body is [Ask](/concepts/ask) |
| read-only | no |
| destructive | yes |
| card address | `ui://scale-intelligence/cards/Ask` |
| HTTP route | [`/v1/act/decide_ask`](/reference/act/decide_ask) |





| field | type | required | note |
|---|---|---|---|
| `ask` | `id` | yes |  |
| `decision` | `one of approve \| decline` | yes |  |
| `reason` | `text` | no |  |


---
title: "tool si.act.decide_brand_design"
description: "the brand, the value's path, the decision (accepted, declined, changed) and, when changed, the tenant's own value, with the reason: the decision as a fact at brand scope: the brand's memory, read by the merge, so a changed value stands as stated by the tenant until the site changes and a declined one is never…"
section: reference
address: /reference/tools/si-act-decide_brand_design
contract: 0476e35e6e275db5
---

# tool si.act.decide_brand_design

the brand, the value's path, the decision (accepted, declined, changed) and, when changed, the tenant's own value, with the reason: the decision as a fact at brand scope: the brand's memory, read by the merge, so a changed value stands as stated by the tenant until the site changes and a declined one is never…

[figure: Over MCP, si.act.decide_brand_design takes DecideBrandDesignInput and returns a card whose body is BrandDecision.]

the decision as a fact at brand scope: the brand's memory, read by the merge, so a changed value stands as stated by the tenant until the site changes and a declined one is never proposed again. The call needs the act grant at the brand rung.



| | |
|---|---|
| input | [DecideBrandDesignInput](/concepts/decidebranddesigninput) |
| result | a card whose body is [BrandDecision](/concepts/branddecision) |
| read-only | no |
| destructive | yes |
| card address | `ui://scale-intelligence/cards/BrandDecision` |
| HTTP route | [`/v1/act/decide_brand_design`](/reference/act/decide_brand_design) |





| field | type | required | note |
|---|---|---|---|
| `brand` | `id` | yes |  |
| `path` | `text` | yes |  |
| `decision` | `one of accepted \| declined \| changed` | yes |  |
| `value` | `json` | no | the tenant's own value, when changed |
| `why` | `text` | no |  |


---
title: "tool si.act.decide_move"
description: "the move, the caller: the move in its new place, with who moved it."
section: reference
address: /reference/tools/si-act-decide_move
contract: 0476e35e6e275db5
---

# tool si.act.decide_move

the move, the caller: the move in its new place, with who moved it.

[figure: Over MCP, si.act.decide_move takes DecideMoveInput and returns a card whose body is Move.]

the move in its new place, with who moved it. The call needs the act grant at the strategy rung.



| | |
|---|---|
| input | [DecideMoveInput](/concepts/decidemoveinput) |
| result | a card whose body is [Move](/concepts/move) |
| read-only | no |
| destructive | yes |
| card address | `ui://scale-intelligence/cards/Move` |
| HTTP route | [`/v1/act/decide_move`](/reference/act/decide_move) |





| field | type | required | note |
|---|---|---|---|
| `move` | `id` | yes |  |
| `decision` | `one of accept \| decline \| stop` | yes |  |
| `reason` | `text` | no |  |


---
title: "tool si.act.deepen"
description: "an observation, and the depth: fetched in full, or given meaning: a deepening."
section: reference
address: /reference/tools/si-act-deepen
contract: 0476e35e6e275db5
---

# tool si.act.deepen

an observation, and the depth: fetched in full, or given meaning: a deepening.

[figure: Over MCP, si.act.deepen takes DeepenInput and returns a card whose body is Deepening.]

a deepening. The call needs the act grant at the strategy rung.



| | |
|---|---|
| input | [DeepenInput](/concepts/deepeninput) |
| result | a card whose body is [Deepening](/concepts/deepening) |
| read-only | no |
| destructive | yes |
| card address | `ui://scale-intelligence/cards/Deepening` |
| HTTP route | [`/v1/act/deepen`](/reference/act/deepen) |





| field | type | required | note |
|---|---|---|---|
| `observation` | `id` | yes |  |
| `depth` | `one of fetch \| embed \| both` | yes |  |
| `asked_by` | [UnitRef](/concepts/unitref) | yes |  |


---
title: "tool si.act.dry_run"
description: "an action: what it would do, and what the inverse would be."
section: reference
address: /reference/tools/si-act-dry_run
contract: 0476e35e6e275db5
---

# tool si.act.dry_run

an action: what it would do, and what the inverse would be.

[figure: Over MCP, si.act.dry_run takes DryRunInput and returns a card whose body is DryRunAnswer.]

what it would do, and what the inverse would be. The call needs the ask grant at the strategy rung.



| | |
|---|---|
| input | [DryRunInput](/concepts/dryruninput) |
| result | a card whose body is [DryRunAnswer](/concepts/dryrunanswer) |
| read-only | no |
| destructive | yes |
| card address | `ui://scale-intelligence/cards/DryRunAnswer` |
| HTTP route | [`/v1/act/dry_run`](/reference/act/dry_run) |





| field | type | required | note |
|---|---|---|---|
| `action` | `id` | yes |  |


---
title: "tool si.act.erase_person"
description: "the person: the erasure as work, then its receipt."
section: reference
address: /reference/tools/si-act-erase_person
contract: 0476e35e6e275db5
---

# tool si.act.erase_person

the person: the erasure as work, then its receipt.

[figure: Over MCP, si.act.erase_person takes ErasePersonInput and returns a card whose body is ErasureReceipt.]

the erasure as work, then its receipt. The call needs the admin grant at the tenant rung.



| | |
|---|---|
| input | [ErasePersonInput](/concepts/erasepersoninput) |
| result | a card whose body is [ErasureReceipt](/concepts/erasurereceipt) |
| read-only | no |
| destructive | yes |
| card address | `ui://scale-intelligence/cards/ErasureReceipt` |
| HTTP route | [`/v1/act/erase_person`](/reference/act/erase_person) |





| field | type | required | note |
|---|---|---|---|
| `person` | `id` | yes |  |
| `verified_by` | `id` | yes |  |


---
title: "tool si.act.export_tenant"
description: "nothing: the export as work, then its receipt."
section: reference
address: /reference/tools/si-act-export_tenant
contract: 0476e35e6e275db5
---

# tool si.act.export_tenant

nothing: the export as work, then its receipt.

[figure: Over MCP, si.act.export_tenant takes Nothing and returns a card whose body is ExportReceipt.]

the export as work, then its receipt. The call needs the admin grant at the tenant rung.



| | |
|---|---|
| input | [Nothing](/concepts/nothing) |
| result | a card whose body is [ExportReceipt](/concepts/exportreceipt) |
| read-only | no |
| destructive | yes |
| card address | `ui://scale-intelligence/cards/ExportReceipt` |
| HTTP route | [`/v1/act/export_tenant`](/reference/act/export_tenant) |


---
title: "tool si.act.goal"
description: "a strategy, a measure, a target, a window: the goal, naming the measure's version."
section: reference
address: /reference/tools/si-act-goal
contract: 0476e35e6e275db5
---

# tool si.act.goal

a strategy, a measure, a target, a window: the goal, naming the measure's version.

[figure: Over MCP, si.act.goal takes GoalInput and returns a card whose body is Goal.]

the goal, naming the measure's version. The call needs the act grant at the strategy rung.



| | |
|---|---|
| input | [GoalInput](/concepts/goalinput) |
| result | a card whose body is [Goal](/concepts/goal) |
| read-only | no |
| destructive | yes |
| card address | `ui://scale-intelligence/cards/Goal` |
| HTTP route | [`/v1/act/goal`](/reference/act/goal) |





| field | type | required | note |
|---|---|---|---|
| `goal` | [Goal](/concepts/goal) | yes |  |


---
title: "tool si.act.grant"
description: "the grant, by a caller who may give it: the grant's new version."
section: reference
address: /reference/tools/si-act-grant
contract: 0476e35e6e275db5
---

# tool si.act.grant

the grant, by a caller who may give it: the grant's new version.

[figure: Over MCP, si.act.grant takes GrantInput and returns a card whose body is Grant.]

the grant's new version. The call needs the act grant at the tenant rung.



| | |
|---|---|
| input | [GrantInput](/concepts/grantinput) |
| result | a card whose body is [Grant](/concepts/grant) |
| read-only | no |
| destructive | yes |
| card address | `ui://scale-intelligence/cards/Grant` |
| HTTP route | [`/v1/act/grant`](/reference/act/grant) |





| field | type | required | note |
|---|---|---|---|
| `grant` | [Grant](/concepts/grant) | no |  |
| `withdraw` | `id` | no |  |
| `reason` | `text` | yes |  |


---
title: "tool si.act.ground"
description: "exactly one of a capture, an entity, a text or an address, and a breadth (`GroundInput`): the grounding with its hypotheses (`GroundingAnswer`), the channels that ran and the ones not ready with their reason."
section: reference
address: /reference/tools/si-act-ground
contract: 0476e35e6e275db5
---

# tool si.act.ground

exactly one of a capture, an entity, a text or an address, and a breadth (`GroundInput`): the grounding with its hypotheses (`GroundingAnswer`), the channels that ran and the ones not ready with their reason.

[figure: Over MCP, si.act.ground takes GroundInput and returns a card whose body is GroundingAnswer.]

the grounding with its hypotheses (`GroundingAnswer`), the channels that ran and the ones not ready with their reason. The call needs the act grant at the user rung.



| | |
|---|---|
| input | [GroundInput](/concepts/groundinput) |
| result | a card whose body is [GroundingAnswer](/concepts/groundinganswer) |
| read-only | no |
| destructive | yes |
| card address | `ui://scale-intelligence/cards/GroundingAnswer` |
| HTTP route | [`/v1/act/ground`](/reference/act/ground) |





| field | type | required | note |
|---|---|---|---|
| `capture` | `hash` | no | the artefact's hash |
| `entity` | `id` | no | an entity of the record |
| `text` | `text` | no | a text a person or the agent pasted, cut to 4,000 characters |
| `address` | `text` | no | an address of a page the record may hold as a capture |
| `breadth` | `one of exact \| similar \| related \| broad` | no | the person's default when absent |


---
title: "tool si.act.hold_identity"
description: "the platform, the scopes the rows declare: a browser session for the person; then the credential with its vault entry."
section: reference
address: /reference/tools/si-act-hold_identity
contract: 0476e35e6e275db5
---

# tool si.act.hold_identity

the platform, the scopes the rows declare: a browser session for the person; then the credential with its vault entry.

[figure: Over MCP, si.act.hold_identity takes HoldIdentityInput and returns a card whose body is SignedInIdentity.]

a browser session for the person; then the credential with its vault entry. The call needs the act grant at the tenant rung.



| | |
|---|---|
| input | [HoldIdentityInput](/concepts/holdidentityinput) |
| result | a card whose body is [SignedInIdentity](/concepts/signedinidentity) |
| read-only | no |
| destructive | yes |
| card address | `ui://scale-intelligence/cards/SignedInIdentity` |
| HTTP route | [`/v1/act/hold_identity`](/reference/act/hold_identity) |





| field | type | required | note |
|---|---|---|---|
| `platform` | `text` | yes | the platform's slug, a row of the platform domains |
| `label` | `text` | yes | the person's name for this identity, unique within the tenant and platform |
| `wait_seconds` | `count` | no | how long the platform waits for the sign-in; the parameter row's value when absent |
| `session` | `id` | no | an open browsing session with a live view in which the person signed in; the platform reads the session's cookies as the session given, so nothing leaves any browser; the web version's way that lasts |
| `cookies` | [HeldCookie](/concepts/heldcookie) | no | the session's cookies given as data, read from the person's own browser by the platform's own extension or pasted by the person, for the web version where no window of the platform can open beside the person; when given, no window opens, and the platform keeps the cookies of the platform's domains and probes them |


---
title: "tool si.act.install_connector"
description: "the connector, the ways chosen, and the identity for each: an installed connector, ready or not ready with its reason."
section: reference
address: /reference/tools/si-act-install_connector
contract: 0476e35e6e275db5
---

# tool si.act.install_connector

the connector, the ways chosen, and the identity for each: an installed connector, ready or not ready with its reason.

[figure: Over MCP, si.act.install_connector takes InstallConnectorInput and returns a card whose body is InstalledConnector.]

an installed connector, ready or not ready with its reason. The call needs the act grant at the brand rung.



| | |
|---|---|
| input | [InstallConnectorInput](/concepts/installconnectorinput) |
| result | a card whose body is [InstalledConnector](/concepts/installedconnector) |
| read-only | no |
| destructive | yes |
| card address | `ui://scale-intelligence/cards/InstalledConnector` |
| HTTP route | [`/v1/act/install_connector`](/reference/act/install_connector) |





| field | type | required | note |
|---|---|---|---|
| `installed` | [InstalledConnector](/concepts/installedconnector) | yes |  |


---
title: "tool si.act.install_pack"
description: "a brand, the pack and its version: the copies made, each naming its origin."
section: reference
address: /reference/tools/si-act-install_pack
contract: 0476e35e6e275db5
---

# tool si.act.install_pack

a brand, the pack and its version: the copies made, each naming its origin.

[figure: Over MCP, si.act.install_pack takes InstallPackInput and returns a card whose body is InstallPackAnswer.]

the copies made, each naming its origin. The call needs the act grant at the brand rung.



| | |
|---|---|
| input | [InstallPackInput](/concepts/installpackinput) |
| result | a card whose body is [InstallPackAnswer](/concepts/installpackanswer) |
| read-only | no |
| destructive | yes |
| card address | `ui://scale-intelligence/cards/InstallPackAnswer` |
| HTTP route | [`/v1/act/install_pack`](/reference/act/install_pack) |





| field | type | required | note |
|---|---|---|---|
| `brand` | `id` | yes |  |
| `template` | `id` | yes |  |
| `version` | `count` | yes |  |


---
title: "tool si.act.invite"
description: "an address and a role: the invitation, open, with its expiry."
section: reference
address: /reference/tools/si-act-invite
contract: 0476e35e6e275db5
---

# tool si.act.invite

an address and a role: the invitation, open, with its expiry.

[figure: Over MCP, si.act.invite takes InviteInput and returns a card whose body is Invitation.]

the invitation, open, with its expiry. The call needs the admin grant at the tenant rung.



| | |
|---|---|
| input | [InviteInput](/concepts/inviteinput) |
| result | a card whose body is [Invitation](/concepts/invitation) |
| read-only | no |
| destructive | yes |
| card address | `ui://scale-intelligence/cards/Invitation` |
| HTTP route | [`/v1/act/invite`](/reference/act/invite) |





| field | type | required | note |
|---|---|---|---|
| `address` | `text` | yes |  |
| `role` | `text` | yes |  |
| `held_on` | [Scope](/concepts/scope) | no | the tenant, brand or strategy the role is held on; absent means the whole tenant, which a guest may not hold (a guest holds roles only on the brands they were invited to) |


---
title: "tool si.act.keep_basket"
description: "its name, its scope and its proxies by version: the basket with its version, not ready while any proxy is."
section: reference
address: /reference/tools/si-act-keep_basket
contract: 0476e35e6e275db5
---

# tool si.act.keep_basket

its name, its scope and its proxies by version: the basket with its version, not ready while any proxy is.

[figure: Over MCP, si.act.keep_basket takes KeepBasketInput and returns a card whose body is ProxyBasket.]

the basket with its version, not ready while any proxy is. The call needs the act grant at the strategy rung.



| | |
|---|---|
| input | [KeepBasketInput](/concepts/keepbasketinput) |
| result | a card whose body is [ProxyBasket](/concepts/proxybasket) |
| read-only | no |
| destructive | yes |
| card address | `ui://scale-intelligence/cards/ProxyBasket` |
| HTTP route | [`/v1/act/keep_basket`](/reference/act/keep_basket) |





| field | type | required | note |
|---|---|---|---|
| `basket` | [ProxyBasket](/concepts/proxybasket) | yes |  |


---
title: "tool si.act.keep_buyer"
description: "the whole profile as it should stand next, with its predicate's tree given in full, its bindings and its ladder: the profile as its next version, ready, or not ready with the compiler's reason; the predicate kept by its hash."
section: reference
address: /reference/tools/si-act-keep_buyer
contract: 0476e35e6e275db5
---

# tool si.act.keep_buyer

the whole profile as it should stand next, with its predicate's tree given in full, its bindings and its ladder: the profile as its next version, ready, or not ready with the compiler's reason; the predicate kept by its hash.

[figure: Over MCP, si.act.keep_buyer takes KeepBuyerInput and returns a card whose body is KindOfBuyer.]

the profile as its next version, ready, or not ready with the compiler's reason; the predicate kept by its hash. The call needs the act grant at the brand rung.



| | |
|---|---|
| input | [KeepBuyerInput](/concepts/keepbuyerinput) |
| result | a card whose body is [KindOfBuyer](/concepts/kindofbuyer) |
| read-only | no |
| destructive | yes |
| card address | `ui://scale-intelligence/cards/KindOfBuyer` |
| HTTP route | [`/v1/act/keep_buyer`](/reference/act/keep_buyer) |





| field | type | required | note |
|---|---|---|---|
| `kind_of_buyer` | [KindOfBuyer](/concepts/kindofbuyer) | yes | the whole profile, with the predicate's tree given in full |


---
title: "tool si.act.keep_ladder"
description: "its ordered rungs, each a predicate over the population, and the rung that qualifies; the rungs' predicates in full where they are not yet kept: the ladder with its version, not ready while a rung's predicate is not kept or does not compile."
section: reference
address: /reference/tools/si-act-keep_ladder
contract: 0476e35e6e275db5
---

# tool si.act.keep_ladder

its ordered rungs, each a predicate over the population, and the rung that qualifies; the rungs' predicates in full where they are not yet kept: the ladder with its version, not ready while a rung's predicate is not kept or does not compile.

[figure: Over MCP, si.act.keep_ladder takes KeepLadderInput and returns a card whose body is Ladder.]

the ladder with its version, not ready while a rung's predicate is not kept or does not compile. The call needs the act grant at the brand rung.



| | |
|---|---|
| input | [KeepLadderInput](/concepts/keepladderinput) |
| result | a card whose body is [Ladder](/concepts/ladder) |
| read-only | no |
| destructive | yes |
| card address | `ui://scale-intelligence/cards/Ladder` |
| HTTP route | [`/v1/act/keep_ladder`](/reference/act/keep_ladder) |





| field | type | required | note |
|---|---|---|---|
| `ladder` | [Ladder](/concepts/ladder) | yes | the rungs carry their predicates by hash; a rung whose predicate is given in full under `predicates` is kept first |
| `predicates` | [Predicate](/concepts/predicate) | no | the rungs' predicates in full, kept by their hashes before the ladder |


---
title: "tool si.act.keep_monitor"
description: "its name, its predicate, the place it runs at, the kind of signal it makes, the strategy where one is chosen, and for a platform monitor the vertical: the monitor with its version, not armed; not ready while its predicate does not compile at its place, with the reasons from compile."
section: reference
address: /reference/tools/si-act-keep_monitor
contract: 0476e35e6e275db5
---

# tool si.act.keep_monitor

its name, its predicate, the place it runs at, the kind of signal it makes, the strategy where one is chosen, and for a platform monitor the vertical: the monitor with its version, not armed; not ready while its predicate does not compile at its place, with the reasons from compile.

[figure: Over MCP, si.act.keep_monitor takes KeepMonitorInput and returns a card whose body is Monitor.]

the monitor with its version, not armed; not ready while its predicate does not compile at its place, with the reasons from compile. The call needs the act grant at the strategy rung.



| | |
|---|---|
| input | [KeepMonitorInput](/concepts/keepmonitorinput) |
| result | a card whose body is [Monitor](/concepts/monitor) |
| read-only | no |
| destructive | yes |
| card address | `ui://scale-intelligence/cards/Monitor` |
| HTTP route | [`/v1/act/keep_monitor`](/reference/act/keep_monitor) |





| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `predicate` | [Predicate](/concepts/predicate) | yes | the tree, compiled at the place |
| `place` | [PlaceARunsAt](/concepts/placearunsat) | yes |  |
| `kind_of_signal` | [KindOfSignal](/concepts/kindofsignal) | yes |  |
| `strategy` | `id` | no | the brand's standing strategy unless one is chosen |
| `vertical` | `text` | no | for a platform monitor |


---
title: "tool si.act.keep_play"
description: "a play for a brand, written once by the platform as an original or by the tenant: its goal, its condition as a predicate over its population, its class, its tactic, the move it proposes, its measure, its window, its forecast rule, its comparison, when it stops, and its graph of moves as edges (`KeepPlayInput`); the…"
section: reference
address: /reference/tools/si-act-keep_play
contract: 0476e35e6e275db5
---

# tool si.act.keep_play

a play for a brand, written once by the platform as an original or by the tenant: its goal, its condition as a predicate over its population, its class, its tactic, the move it proposes, its measure, its window, its forecast rule, its comparison, when it stops, and its graph of moves as edges (`KeepPlayInput`); the…

[figure: Over MCP, si.act.keep_play takes KeepPlayInput and returns a card whose body is Play.]

the play as the next version of its name under the brand, ready, or not ready with the first reason: *the condition does not compile*, *the graph has a cycle* naming the edge, *an edge cannot be evaluated* naming the edge and the population, *an edge is neither always nor guarded*. The call needs the act grant at the brand rung.



| | |
|---|---|
| input | [KeepPlayInput](/concepts/keepplayinput) |
| result | a card whose body is [Play](/concepts/play) |
| read-only | no |
| destructive | yes |
| card address | `ui://scale-intelligence/cards/Play` |
| HTTP route | [`/v1/act/keep_play`](/reference/act/keep_play) |





| field | type | required | note |
|---|---|---|---|
| `play` | [Play](/concepts/play) | yes | its condition and its edges carry their predicates by hash; a predicate given in full under `predicates` is kept first |
| `predicates` | [Predicate](/concepts/predicate) | no | the condition's and the edges' predicates in full, kept by their hashes before the play |


---
title: "tool si.act.keep_proxy"
description: "a proxy: its name, the facet kind it stands for, its scope, its rule as a predicate, its strength, its named control, its failure mode, and whether it is aggregate-only: the proxy with its version by hash, not ready until its controls have run and its calibration is read."
section: reference
address: /reference/tools/si-act-keep_proxy
contract: 0476e35e6e275db5
---

# tool si.act.keep_proxy

a proxy: its name, the facet kind it stands for, its scope, its rule as a predicate, its strength, its named control, its failure mode, and whether it is aggregate-only: the proxy with its version by hash, not ready until its controls have run and its calibration is read.

[figure: Over MCP, si.act.keep_proxy takes KeepProxyInput and returns a card whose body is Proxy.]

the proxy with its version by hash, not ready until its controls have run and its calibration is read. The call needs the act grant at the strategy rung.



| | |
|---|---|
| input | [KeepProxyInput](/concepts/keepproxyinput) |
| result | a card whose body is [Proxy](/concepts/proxy) |
| read-only | no |
| destructive | yes |
| card address | `ui://scale-intelligence/cards/Proxy` |
| HTTP route | [`/v1/act/keep_proxy`](/reference/act/keep_proxy) |





| field | type | required | note |
|---|---|---|---|
| `proxy` | [Proxy](/concepts/proxy) | yes |  |


---
title: "tool si.act.make_brand_design_system"
description: "the brand, and the site when it is not the brand row's own: the brand's design system as the next version of its name: every colour, face, size, step, radius, shadow and the logo, each measured, inferred by a named rule or never measured, with the artefacts it was read from and the gaps; and the same values in the…"
section: reference
address: /reference/tools/si-act-make_brand_design_system
contract: 0476e35e6e275db5
---

# tool si.act.make_brand_design_system

the brand, and the site when it is not the brand row's own: the brand's design system as the next version of its name: every colour, face, size, step, radius, shadow and the logo, each measured, inferred by a named rule or never measured, with the artefacts it was read from and the gaps; and the same values in the…

[figure: Over MCP, si.act.make_brand_design_system takes MakeBrandDesignSystemInput and returns a card whose body is BrandDesignSystem.]

the brand's design system as the next version of its name: every colour, face, size, step, radius, shadow and the logo, each measured, inferred by a named rule or never measured, with the artefacts it was read from and the gaps; and the same values in the platform's token shape. The call needs the act grant at the brand rung.



| | |
|---|---|
| input | [MakeBrandDesignSystemInput](/concepts/makebranddesignsysteminput) |
| result | a card whose body is [BrandDesignSystem](/concepts/branddesignsystem) |
| read-only | no |
| destructive | yes |
| card address | `ui://scale-intelligence/cards/BrandDesignSystem` |
| HTTP route | [`/v1/act/make_brand_design_system`](/reference/act/make_brand_design_system) |





| field | type | required | note |
|---|---|---|---|
| `brand` | `id` | yes |  |
| `website` | `address` | no | defaults to the brand row's own |


---
title: "tool si.act.make_market_twin"
description: "Makes one market twin from a vertical, a segment, a brand, a template and the way of going to market it serves: The answer gives the twin, ready or not ready with the stock the record cannot read named."
section: reference
address: /reference/tools/si-act-make_market_twin
contract: 0476e35e6e275db5
---

# tool si.act.make_market_twin

Makes one market twin from a vertical, a segment, a brand, a template and the way of going to market it serves: The answer gives the twin, ready or not ready with the stock the record cannot read named.

[figure: Over MCP, si.act.make_market_twin takes MakeMarketTwinInput and returns a card whose body is MarketTwin.]

The answer gives the twin, ready or not ready with the stock the record cannot read named. The call needs the act grant at the brand rung.



| | |
|---|---|
| input | [MakeMarketTwinInput](/concepts/makemarkettwininput) |
| result | a card whose body is [MarketTwin](/concepts/markettwin) |
| read-only | no |
| destructive | yes |
| card address | `ui://scale-intelligence/cards/MarketTwin` |
| HTTP route | [`/v1/act/make_market_twin`](/reference/act/make_market_twin) |





| field | type | required | note |
|---|---|---|---|
| `vertical` | `id` | yes |  |
| `segment` | `id` | no |  |
| `brand` | `id` | yes |  |
| `template` | [SystemsModelTemplate](/concepts/systemsmodeltemplate) | yes |  |
| `way` | [WayOfGoingToMarket](/concepts/wayofgoingtomarket) | no |  |
| `as_of` | `time` | no | today when absent |


---
title: "tool si.act.map_brand"
description: "a web address, and the brand scope to hold the map: the map as it stands, with every part measured or never measured, and the demand raised."
section: reference
address: /reference/tools/si-act-map_brand
contract: 0476e35e6e275db5
---

# tool si.act.map_brand

a web address, and the brand scope to hold the map: the map as it stands, with every part measured or never measured, and the demand raised.

[figure: Over MCP, si.act.map_brand takes MapBrandInput and returns a card whose body is Map.]

the map as it stands, with every part measured or never measured, and the demand raised. The call needs the act grant at the brand rung.



| | |
|---|---|
| input | [MapBrandInput](/concepts/mapbrandinput) |
| result | a card whose body is [Map](/concepts/map) |
| read-only | no |
| destructive | yes |
| card address | `ui://scale-intelligence/cards/Map` |
| HTTP route | [`/v1/act/map_brand`](/reference/act/map_brand) |





| field | type | required | note |
|---|---|---|---|
| `website` | `address` | yes |  |
| `name` | `text` | no |  |
| `tenant` | `id` | yes |  |


---
title: "tool si.act.mark_lead"
description: "Marks a condition on one lead, with a reason where the condition asks for one: The answer gives the lead's new outcome."
section: reference
address: /reference/tools/si-act-mark_lead
contract: 0476e35e6e275db5
---

# tool si.act.mark_lead

Marks a condition on one lead, with a reason where the condition asks for one: The answer gives the lead's new outcome.

[figure: Over MCP, si.act.mark_lead takes MarkLeadInput and returns a card whose body is Outcome.]

The answer gives the lead's new outcome. The call needs the act grant at the strategy rung.



| | |
|---|---|
| input | [MarkLeadInput](/concepts/markleadinput) |
| result | a card whose body is [Outcome](/concepts/outcome) |
| read-only | no |
| destructive | yes |
| card address | `ui://scale-intelligence/cards/Outcome` |
| HTTP route | [`/v1/act/mark_lead`](/reference/act/mark_lead) |





| field | type | required | note |
|---|---|---|---|
| `lead` | `id` | yes |  |
| `condition` | [LeadCondition](/concepts/leadcondition) | yes |  |
| `reason` | `text` | no |  |


---
title: "tool si.act.mark_rival"
description: "a brand, the rival's entity, the evidence: the fact."
section: reference
address: /reference/tools/si-act-mark_rival
contract: 0476e35e6e275db5
---

# tool si.act.mark_rival

a brand, the rival's entity, the evidence: the fact.

[figure: Over MCP, si.act.mark_rival takes MarkRivalInput and returns a card whose body is RivalMarking.]

the fact. The call needs the act grant at the brand rung.



| | |
|---|---|
| input | [MarkRivalInput](/concepts/markrivalinput) |
| result | a card whose body is [RivalMarking](/concepts/rivalmarking) |
| read-only | no |
| destructive | yes |
| card address | `ui://scale-intelligence/cards/RivalMarking` |
| HTTP route | [`/v1/act/mark_rival`](/reference/act/mark_rival) |





| field | type | required | note |
|---|---|---|---|
| `brand` | `id` | yes |  |
| `rival` | `id` | yes |  |
| `evidence` | [EvidenceRef](/concepts/evidenceref) | yes |  |


---
title: "tool si.act.membership"
description: "the person's address, and the roles with where each is held: the membership."
section: reference
address: /reference/tools/si-act-membership
contract: 0476e35e6e275db5
---

# tool si.act.membership

the person's address, and the roles with where each is held: the membership.

[figure: Over MCP, si.act.membership takes MembershipInput and returns a card whose body is Membership.]

the membership. The call needs the act grant at the tenant rung.



| | |
|---|---|
| input | [MembershipInput](/concepts/membershipinput) |
| result | a card whose body is [Membership](/concepts/membership) |
| read-only | no |
| destructive | yes |
| card address | `ui://scale-intelligence/cards/Membership` |
| HTTP route | [`/v1/act/membership`](/reference/act/membership) |





| field | type | required | note |
|---|---|---|---|
| `user` | `id` | no |  |
| `mail` | `address` | no | to invite |
| `tenant` | `id` | yes |  |
| `do` | `one of invite \| suspend \| remove` | yes |  |
| `kind` | `one of member \| guest` | no |  |


---
title: "tool si.act.move_strategy"
description: "a strategy, the place to move it to and the reason (`StrategyMoveInput`): drafted, simulated, rolled out in part, running, paused, ended: the `Strategy` in its new place, with who moved it."
section: reference
address: /reference/tools/si-act-move_strategy
contract: 0476e35e6e275db5
---

# tool si.act.move_strategy

a strategy, the place to move it to and the reason (`StrategyMoveInput`): drafted, simulated, rolled out in part, running, paused, ended: the `Strategy` in its new place, with who moved it.

[figure: Over MCP, si.act.move_strategy takes StrategyMoveInput and returns a card whose body is Strategy.]

the `Strategy` in its new place, with who moved it. The call needs the act grant at the strategy rung.



| | |
|---|---|
| input | [StrategyMoveInput](/concepts/strategymoveinput) |
| result | a card whose body is [Strategy](/concepts/strategy) |
| read-only | no |
| destructive | yes |
| card address | `ui://scale-intelligence/cards/Strategy` |
| HTTP route | [`/v1/act/move_strategy`](/reference/act/move_strategy) |





| field | type | required | note |
|---|---|---|---|
| `strategy` | `id` | yes |  |
| `to` | `one of drafted \| simulated \| rolled out in part \| running \| paused \| ended` | yes |  |
| `reason` | `text` | yes |  |


---
title: "tool si.act.notification_channel"
description: "Writes one notification channel, which is where a notice goes: The channel is ready once its test notice is acknowledged."
section: reference
address: /reference/tools/si-act-notification_channel
contract: 0476e35e6e275db5
---

# tool si.act.notification_channel

Writes one notification channel, which is where a notice goes: The channel is ready once its test notice is acknowledged.

[figure: Over MCP, si.act.notification_channel takes NotificationChannelInput and returns a card whose body is NotificationChannel.]

The channel is ready once its test notice is acknowledged. Until then it is not ready, with the reason. The call needs the act grant at the user rung.



| | |
|---|---|
| input | [NotificationChannelInput](/concepts/notificationchannelinput) |
| result | a card whose body is [NotificationChannel](/concepts/notificationchannel) |
| read-only | no |
| destructive | yes |
| card address | `ui://scale-intelligence/cards/NotificationChannel` |
| HTTP route | [`/v1/act/notification_channel`](/reference/act/notification_channel) |





| field | type | required | note |
|---|---|---|---|
| `kind` | `one of in the app \| email \| Slack \| webhook \| the extension` | yes |  |
| `address` | `text` | yes |  |
| `notices` | `[text]` | yes |  |


---
title: "tool si.act.notification_rule"
description: "Writes one notification rule, which says who is told and never what happens: The answer gives the rule, with the next notice it will send."
section: reference
address: /reference/tools/si-act-notification_rule
contract: 0476e35e6e275db5
---

# tool si.act.notification_rule

Writes one notification rule, which says who is told and never what happens: The answer gives the rule, with the next notice it will send.

[figure: Over MCP, si.act.notification_rule takes NotificationRuleInput and returns a card whose body is NotificationRule.]

The answer gives the rule, with the next notice it will send. The call needs the act grant at the user rung.



| | |
|---|---|
| input | [NotificationRuleInput](/concepts/notificationruleinput) |
| result | a card whose body is [NotificationRule](/concepts/notificationrule) |
| read-only | no |
| destructive | yes |
| card address | `ui://scale-intelligence/cards/NotificationRule` |
| HTTP route | [`/v1/act/notification_rule`](/reference/act/notification_rule) |





| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `notices` | `[text]` | yes |  |
| `channel` | [NotificationChannel](/concepts/notificationchannel) | yes |  |
| `quiet_hours` | `text` | no |  |
| `digest` | `one of none \| hourly \| daily` | yes |  |


---
title: "tool si.act.parameter"
description: "a parameter by its name, its value and its scope: the parameter as written, at its new version."
section: reference
address: /reference/tools/si-act-parameter
contract: 0476e35e6e275db5
---

# tool si.act.parameter

a parameter by its name, its value and its scope: the parameter as written, at its new version.

[figure: Over MCP, si.act.parameter takes ParameterWriteInput and returns a card whose body is Parameter.]

the parameter as written, at its new version. The call needs the act grant at the user rung.



| | |
|---|---|
| input | [ParameterWriteInput](/concepts/parameterwriteinput) |
| result | a card whose body is [Parameter](/concepts/parameter) |
| read-only | no |
| destructive | yes |
| card address | `ui://scale-intelligence/cards/Parameter` |
| HTTP route | [`/v1/act/parameter`](/reference/act/parameter) |





| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `value` | `json` | yes |  |
| `scope` | [Scope](/concepts/scope) | no | the caller's tenant when absent |


---
title: "tool si.act.place_participant"
description: "Places one party in one role on one stock of a vertical's chain, with the evidence for it: The answer gives the participant, ready or not ready with the reason."
section: reference
address: /reference/tools/si-act-place_participant
contract: 0476e35e6e275db5
---

# tool si.act.place_participant

Places one party in one role on one stock of a vertical's chain, with the evidence for it: The answer gives the participant, ready or not ready with the reason.

[figure: Over MCP, si.act.place_participant takes PlaceParticipantInput and returns a card whose body is MarketParticipant.]

The answer gives the participant, ready or not ready with the reason. The call needs the act grant at the brand rung.



| | |
|---|---|
| input | [PlaceParticipantInput](/concepts/placeparticipantinput) |
| result | a card whose body is [MarketParticipant](/concepts/marketparticipant) |
| read-only | no |
| destructive | yes |
| card address | `ui://scale-intelligence/cards/MarketParticipant` |
| HTTP route | [`/v1/act/place_participant`](/reference/act/place_participant) |





| field | type | required | note |
|---|---|---|---|
| `vertical` | `id` | yes |  |
| `segment` | `id` | no |  |
| `stock` | `text` | yes |  |
| `party` | `id` | yes |  |
| `party_kind` | `one of company \| brand \| person \| account \| community \| organisation` | yes |  |
| `role` | [RoleAroundADecision](/concepts/rolearoundadecision) | yes |  |
| `side` | `one of demand \| supply \| intermediary \| influence \| rules` | yes |  |
| `impact_on` | [ParticipantImpact](/concepts/participantimpact) | no |  |
| `evidence` | [EvidenceRef](/concepts/evidenceref) | yes |  |


---
title: "tool si.act.probe_identity"
description: "the identity: its readiness with the reason."
section: reference
address: /reference/tools/si-act-probe_identity
contract: 0476e35e6e275db5
---

# tool si.act.probe_identity

the identity: its readiness with the reason.

[figure: Over MCP, si.act.probe_identity takes ProbeIdentityInput and returns a card whose body is Readiness.]

its readiness with the reason. The call needs the act grant at the tenant rung.



| | |
|---|---|
| input | [ProbeIdentityInput](/concepts/probeidentityinput) |
| result | a card whose body is [Readiness](/concepts/readiness) |
| read-only | no |
| destructive | yes |
| card address | `ui://scale-intelligence/cards/Readiness` |
| HTTP route | [`/v1/act/probe_identity`](/reference/act/probe_identity) |





| field | type | required | note |
|---|---|---|---|
| `identity` | `id` | yes |  |


---
title: "tool si.act.propose_move"
description: "a match of a play: the move, proposed, with its forecast and its assignments as facts."
section: reference
address: /reference/tools/si-act-propose_move
contract: 0476e35e6e275db5
---

# tool si.act.propose_move

a match of a play: the move, proposed, with its forecast and its assignments as facts.

[figure: Over MCP, si.act.propose_move takes ProposeMoveInput and returns a card whose body is Move.]

the move, proposed, with its forecast and its assignments as facts. The call needs the act grant at the strategy rung.



| | |
|---|---|
| input | [ProposeMoveInput](/concepts/proposemoveinput) |
| result | a card whose body is [Move](/concepts/move) |
| read-only | no |
| destructive | yes |
| card address | `ui://scale-intelligence/cards/Move` |
| HTTP route | [`/v1/act/propose_move`](/reference/act/propose_move) |





| field | type | required | note |
|---|---|---|---|
| `play` | `id` | yes |  |
| `catch` | `id` | no |  |
| `strategy` | `id` | yes |  |


---
title: "tool si.act.publish"
description: "the version, the address, the visibility: the publishing, proposed or published, and its receipt."
section: reference
address: /reference/tools/si-act-publish
contract: 0476e35e6e275db5
---

# tool si.act.publish

the version, the address, the visibility: the publishing, proposed or published, and its receipt.

[figure: Over MCP, si.act.publish takes PublishInput and returns a card whose body is Publishing.]

the publishing, proposed or published, and its receipt. The call needs the act grant at the brand rung.



| | |
|---|---|
| input | [PublishInput](/concepts/publishinput) |
| result | a card whose body is [Publishing](/concepts/publishing) |
| read-only | no |
| destructive | yes |
| card address | `ui://scale-intelligence/cards/Publishing` |
| HTTP route | [`/v1/act/publish`](/reference/act/publish) |





| field | type | required | note |
|---|---|---|---|
| `build` | `id` | yes |  |
| `address` | `address` | yes |  |
| `key` | `id` | no |  |


---
title: "tool si.act.raise_need"
description: "a cell's key, the reason and the value: the cell, wanted."
section: reference
address: /reference/tools/si-act-raise_need
contract: 0476e35e6e275db5
---

# tool si.act.raise_need

a cell's key, the reason and the value: the cell, wanted.

[figure: Over MCP, si.act.raise_need takes RaiseNeedInput and returns a card whose body is DemandCell.]

the cell, wanted. The call needs the act grant at the brand rung.



| | |
|---|---|
| input | [RaiseNeedInput](/concepts/raiseneedinput) |
| result | a card whose body is [DemandCell](/concepts/demandcell) |
| read-only | no |
| destructive | yes |
| card address | `ui://scale-intelligence/cards/DemandCell` |
| HTTP route | [`/v1/act/raise_need`](/reference/act/raise_need) |





| field | type | required | note |
|---|---|---|---|
| `source` | [Source](/concepts/source) | yes |  |
| `entities` | [Predicate](/concepts/predicate) | yes |  |
| `bucket` | [Window](/concepts/window) | yes |  |
| `fields` | `[text]` | yes |  |
| `value` | `share` | yes |  |


---
title: "tool si.act.record_fit_reading"
description: "Records one result of a person's own test: the tactic, the market, the measure, its value, the sample and where it came from: The answer gives the reading as a fact the record keeps."
section: reference
address: /reference/tools/si-act-record_fit_reading
contract: 0476e35e6e275db5
---

# tool si.act.record_fit_reading

Records one result of a person's own test: the tactic, the market, the measure, its value, the sample and where it came from: The answer gives the reading as a fact the record keeps.

[figure: Over MCP, si.act.record_fit_reading takes FitReadingInput and returns a card whose body is FitReading.]

The answer gives the reading as a fact the record keeps. The call needs the act grant at the brand rung.



| | |
|---|---|
| input | [FitReadingInput](/concepts/fitreadinginput) |
| result | a card whose body is [FitReading](/concepts/fitreading) |
| read-only | no |
| destructive | yes |
| card address | `ui://scale-intelligence/cards/FitReading` |
| HTTP route | [`/v1/act/record_fit_reading`](/reference/act/record_fit_reading) |





| field | type | required | note |
|---|---|---|---|
| `tactic` | [Tactic](/concepts/tactic) | yes |  |
| `vertical` | `id` | yes |  |
| `segment` | `id` | no |  |
| `offering` | `id` | no |  |
| `measure` | [KindOfMeasure](/concepts/kindofmeasure) | yes |  |
| `value` | `json` | yes | the number, or never measured with the reason |
| `sample` | `count` | no |  |
| `source` | `one of a form \| a CRM \| a capture \| an upload \| a call \| the record` | yes |  |
| `hypothesis` | `id` | no |  |
| `note` | `text` | no |  |


---
title: "tool si.act.remember"
description: "a memory and its scope: the memory, or a later fact that ends it."
section: reference
address: /reference/tools/si-act-remember
contract: 0476e35e6e275db5
---

# tool si.act.remember

a memory and its scope: the memory, or a later fact that ends it.

[figure: Over MCP, si.act.remember takes RememberInput and returns a card whose body is Memory.]

the memory, or a later fact that ends it. The call needs the act grant at the strategy rung.



| | |
|---|---|
| input | [RememberInput](/concepts/rememberinput) |
| result | a card whose body is [Memory](/concepts/memory) |
| read-only | no |
| destructive | yes |
| card address | `ui://scale-intelligence/cards/Memory` |
| HTTP route | [`/v1/act/remember`](/reference/act/remember) |





| field | type | required | note |
|---|---|---|---|
| `memory` | [Memory](/concepts/memory) | no |  |
| `forget` | `id` | no |  |


---
title: "tool si.act.routing"
description: "Writes, previews or arms a routing rule from a predicate and the people or the team it attaches: A write or an arm gives the rule."
section: reference
address: /reference/tools/si-act-routing
contract: 0476e35e6e275db5
---

# tool si.act.routing

Writes, previews or arms a routing rule from a predicate and the people or the team it attaches: A write or an arm gives the rule.

[figure: Over MCP, si.act.routing takes RoutingInput and returns a card whose body is RoutingAnswer.]

A write or an arm gives the rule. A preview gives the leads it would have admitted and who would have had them, read over history. The call needs the act grant at the brand rung.



| | |
|---|---|
| input | [RoutingInput](/concepts/routinginput) |
| result | a card whose body is [RoutingAnswer](/concepts/routinganswer) |
| read-only | no |
| destructive | yes |
| card address | `ui://scale-intelligence/cards/RoutingAnswer` |
| HTTP route | [`/v1/act/routing`](/reference/act/routing) |





| field | type | required | note |
|---|---|---|---|
| `rule` | [RoutingRule](/concepts/routingrule) | yes |  |
| `do` | `one of write \| preview \| arm` | yes |  |


---
title: "tool si.act.run_action"
description: "an action prepared by a move: the action, allowed or not allowed with the reason, then running, then done or failed."
section: reference
address: /reference/tools/si-act-run_action
contract: 0476e35e6e275db5
---

# tool si.act.run_action

an action prepared by a move: the action, allowed or not allowed with the reason, then running, then done or failed.

[figure: Over MCP, si.act.run_action takes RunActionInput and returns a card whose body is Action.]

the action, allowed or not allowed with the reason, then running, then done or failed. The call needs the act grant at the strategy rung.



| | |
|---|---|
| input | [RunActionInput](/concepts/runactioninput) |
| result | a card whose body is [Action](/concepts/action) |
| read-only | no |
| destructive | yes |
| card address | `ui://scale-intelligence/cards/Action` |
| HTTP route | [`/v1/act/run_action`](/reference/act/run_action) |





| field | type | required | note |
|---|---|---|---|
| `action` | `id` | yes |  |


---
title: "tool si.act.scrape_template"
description: "a `TemplateInput`: the template, ready or not ready with the reason; for a preview, the rows from its samples and a bounded live scope."
section: reference
address: /reference/tools/si-act-scrape_template
contract: 0476e35e6e275db5
---

# tool si.act.scrape_template

a `TemplateInput`: the template, ready or not ready with the reason; for a preview, the rows from its samples and a bounded live scope.

[figure: Over MCP, si.act.scrape_template takes TemplateInput and returns a card whose body is ExtractionTemplate.]

the template, ready or not ready with the reason; for a preview, the rows from its samples and a bounded live scope. The call needs the act grant at the brand rung.



| | |
|---|---|
| input | [TemplateInput](/concepts/templateinput) |
| result | a card whose body is [ExtractionTemplate](/concepts/extractiontemplate) |
| read-only | no |
| destructive | yes |
| card address | `ui://scale-intelligence/cards/ExtractionTemplate` |
| HTTP route | [`/v1/act/scrape_template`](/reference/act/scrape_template) |





| field | type | required | note |
|---|---|---|---|
| `template` | [ExtractionTemplate](/concepts/extractiontemplate) | yes |  |
| `flow` | `one of write \| preview \| arm \| disarm \| retire` | yes |  |


---
title: "tool si.act.seed_tenant"
description: "the manifest and the window: the seed as work, then its receipt with counts by kind and what is not ready."
section: reference
address: /reference/tools/si-act-seed_tenant
contract: 0476e35e6e275db5
---

# tool si.act.seed_tenant

the manifest and the window: the seed as work, then its receipt with counts by kind and what is not ready.

[figure: Over MCP, si.act.seed_tenant takes SeedInput and returns a card whose body is SeedReceipt.]

the seed as work, then its receipt with counts by kind and what is not ready. The call needs the admin grant at the platform rung.



| | |
|---|---|
| input | [SeedInput](/concepts/seedinput) |
| result | a card whose body is [SeedReceipt](/concepts/seedreceipt) |
| read-only | no |
| destructive | yes |
| card address | `ui://scale-intelligence/cards/SeedReceipt` |
| HTTP route | [`/v1/act/seed_tenant`](/reference/act/seed_tenant) |





| field | type | required | note |
|---|---|---|---|
| `manifest` | `id` | yes |  |
| `window_months` | `count` | no | the parameter's value when empty |


---
title: "tool si.act.set_aside_run"
description: "a `SetAsideRunInput`: the run's key and a person's plain reason: the `ScrapeRun`, kept in the parked place with the reason, which the beat never takes up; each move is an event with the reason."
section: reference
address: /reference/tools/si-act-set_aside_run
contract: 0476e35e6e275db5
---

# tool si.act.set_aside_run

a `SetAsideRunInput`: the run's key and a person's plain reason: the `ScrapeRun`, kept in the parked place with the reason, which the beat never takes up; each move is an event with the reason.

[figure: Over MCP, si.act.set_aside_run takes SetAsideRunInput and returns a card whose body is ScrapeRun.]

the `ScrapeRun`, kept in the parked place with the reason, which the beat never takes up; each move is an event with the reason. The call needs the act grant at the tenant rung.



| | |
|---|---|
| input | [SetAsideRunInput](/concepts/setasideruninput) |
| result | a card whose body is [ScrapeRun](/concepts/scraperun) |
| read-only | no |
| destructive | yes |
| card address | `ui://scale-intelligence/cards/ScrapeRun` |
| HTTP route | [`/v1/act/set_aside_run`](/reference/act/set_aside_run) |





| field | type | required | note |
|---|---|---|---|
| `run` | `text` | yes | the run's key, as the runs read lists it |
| `reason` | `text` | yes | the plain reason the run waits, which its row and its event carry |


---
title: "tool si.act.settle"
description: "a hypothesis, the standing, the caller: the hypothesis settled, with who settled it and on what."
section: reference
address: /reference/tools/si-act-settle
contract: 0476e35e6e275db5
---

# tool si.act.settle

a hypothesis, the standing, the caller: the hypothesis settled, with who settled it and on what.

[figure: Over MCP, si.act.settle takes SettleInput and returns a card whose body is Hypothesis.]

the hypothesis settled, with who settled it and on what. The call needs the act grant at the strategy rung.



| | |
|---|---|
| input | [SettleInput](/concepts/settleinput) |
| result | a card whose body is [Hypothesis](/concepts/hypothesis) |
| read-only | no |
| destructive | yes |
| card address | `ui://scale-intelligence/cards/Hypothesis` |
| HTTP route | [`/v1/act/settle`](/reference/act/settle) |





| field | type | required | note |
|---|---|---|---|
| `hypothesis` | `id` | yes |  |
| `standing` | `one of supported \| refuted \| cannot tell \| under test` | yes |  |
| `on` | `text` | yes | what it was settled on |


---
title: "tool si.act.settle_match"
description: "the possible match, and a user's answer or a proof: confirmed, with the merge."
section: reference
address: /reference/tools/si-act-settle_match
contract: 0476e35e6e275db5
---

# tool si.act.settle_match

the possible match, and a user's answer or a proof: confirmed, with the merge.

[figure: Over MCP, si.act.settle_match takes SettleMatchInput and returns a card whose body is SettleMatchAnswer.]

confirmed, with the merge. Or rejected. The call needs the act grant at the brand rung.



| | |
|---|---|
| input | [SettleMatchInput](/concepts/settlematchinput) |
| result | a card whose body is [SettleMatchAnswer](/concepts/settlematchanswer) |
| read-only | no |
| destructive | yes |
| card address | `ui://scale-intelligence/cards/SettleMatchAnswer` |
| HTTP route | [`/v1/act/settle_match`](/reference/act/settle_match) |





| field | type | required | note |
|---|---|---|---|
| `match` | `id` | yes |  |
| `decision` | `one of confirm \| reject` | yes |  |
| `evidence` | [EvidenceRef](/concepts/evidenceref) | no |  |


---
title: "tool si.act.sign_up"
description: "the company's name, and its domain where known, from a signed-in person who belongs to no tenant: the tenant, made on the trial plan with the person as its first member and owner, in one transaction with its events."
section: reference
address: /reference/tools/si-act-sign_up
contract: 0476e35e6e275db5
---

# tool si.act.sign_up

the company's name, and its domain where known, from a signed-in person who belongs to no tenant: the tenant, made on the trial plan with the person as its first member and owner, in one transaction with its events.

[figure: Over MCP, si.act.sign_up takes SignUpInput and returns a card whose body is Tenant.]

the tenant, made on the trial plan with the person as its first member and owner, in one transaction with its events. The call needs the act grant at the user rung.



| | |
|---|---|
| input | [SignUpInput](/concepts/signupinput) |
| result | a card whose body is [Tenant](/concepts/tenant) |
| read-only | no |
| destructive | yes |
| card address | `ui://scale-intelligence/cards/Tenant` |
| HTTP route | [`/v1/act/sign_up`](/reference/act/sign_up) |





| field | type | required | note |
|---|---|---|---|
| `company` | `text` | yes | the company's name as the person states it |
| `domain` | `text` | no | the company's website, which the map from a domain reads next |


---
title: "tool si.act.strategy"
description: "a brand or brands, a name, a window if any: the strategy, with the standing measures."
section: reference
address: /reference/tools/si-act-strategy
contract: 0476e35e6e275db5
---

# tool si.act.strategy

a brand or brands, a name, a window if any: the strategy, with the standing measures.

[figure: Over MCP, si.act.strategy takes StrategyInput and returns a card whose body is Strategy.]

the strategy, with the standing measures. The call needs the act grant at the brand rung.



| | |
|---|---|
| input | [StrategyInput](/concepts/strategyinput) |
| result | a card whose body is [Strategy](/concepts/strategy) |
| read-only | no |
| destructive | yes |
| card address | `ui://scale-intelligence/cards/Strategy` |
| HTTP route | [`/v1/act/strategy`](/reference/act/strategy) |





| field | type | required | note |
|---|---|---|---|
| `strategy` | [Strategy](/concepts/strategy) | yes |  |


---
title: "tool si.act.sync_rule"
description: "the installed connector, the offer, the fields of section 2.8: the rule; for a preview, what it would read and push."
section: reference
address: /reference/tools/si-act-sync_rule
contract: 0476e35e6e275db5
---

# tool si.act.sync_rule

the installed connector, the offer, the fields of section 2.8: the rule; for a preview, what it would read and push.

[figure: Over MCP, si.act.sync_rule takes SyncRuleInput and returns a card whose body is SyncPreview.]

the rule; for a preview, what it would read and push. The call needs the act grant at the brand rung.



| | |
|---|---|
| input | [SyncRuleInput](/concepts/syncruleinput) |
| result | a card whose body is [SyncPreview](/concepts/syncpreview) |
| read-only | no |
| destructive | yes |
| card address | `ui://scale-intelligence/cards/SyncPreview` |
| HTTP route | [`/v1/act/sync_rule`](/reference/act/sync_rule) |





| field | type | required | note |
|---|---|---|---|
| `rule` | [SyncRule](/concepts/syncrule) | yes |  |
| `flow` | `one of write \| preview \| arm \| disarm` | yes |  |


---
title: "tool si.act.undo"
description: "a done action: the action, undone, and the inverse's own action."
section: reference
address: /reference/tools/si-act-undo
contract: 0476e35e6e275db5
---

# tool si.act.undo

a done action: the action, undone, and the inverse's own action.

[figure: Over MCP, si.act.undo takes UndoInput and returns a card whose body is UndoAnswer.]

the action, undone, and the inverse's own action. The call needs the act grant at the strategy rung.



| | |
|---|---|
| input | [UndoInput](/concepts/undoinput) |
| result | a card whose body is [UndoAnswer](/concepts/undoanswer) |
| read-only | no |
| destructive | yes |
| card address | `ui://scale-intelligence/cards/UndoAnswer` |
| HTTP route | [`/v1/act/undo`](/reference/act/undo) |





| field | type | required | note |
|---|---|---|---|
| `action` | `id` | yes |  |
| `reason` | `text` | yes |  |


---
title: "tool si.act.undo_action"
description: "the move: the inverse move."
section: reference
address: /reference/tools/si-act-undo_action
contract: 0476e35e6e275db5
---

# tool si.act.undo_action

the move: the inverse move.

[figure: Over MCP, si.act.undo_action takes UndoActionInput and returns a card whose body is Move.]

the inverse move. The call needs the act grant at the brand rung.



| | |
|---|---|
| input | [UndoActionInput](/concepts/undoactioninput) |
| result | a card whose body is [Move](/concepts/move) |
| read-only | no |
| destructive | yes |
| card address | `ui://scale-intelligence/cards/Move` |
| HTTP route | [`/v1/act/undo_action`](/reference/act/undo_action) |





| field | type | required | note |
|---|---|---|---|
| `move` | `id` | yes |  |


---
title: "tool si.act.undo_merge"
description: "the merge or the decision, and the reason: a parting."
section: reference
address: /reference/tools/si-act-undo_merge
contract: 0476e35e6e275db5
---

# tool si.act.undo_merge

the merge or the decision, and the reason: a parting.

[figure: Over MCP, si.act.undo_merge takes UndoMergeInput and returns a card whose body is UndoMergeAnswer.]

a parting. Or a later decision, with the facts written again. The call needs the act grant at the brand rung.



| | |
|---|---|
| input | [UndoMergeInput](/concepts/undomergeinput) |
| result | a card whose body is [UndoMergeAnswer](/concepts/undomergeanswer) |
| read-only | no |
| destructive | yes |
| card address | `ui://scale-intelligence/cards/UndoMergeAnswer` |
| HTTP route | [`/v1/act/undo_merge`](/reference/act/undo_merge) |





| field | type | required | note |
|---|---|---|---|
| `merge` | `id` | no |  |
| `decision` | `id` | no |  |
| `reason` | `text` | yes |  |


---
title: "tool si.act.watch"
description: "a public entity: a watched identity, with its monitor armed."
section: reference
address: /reference/tools/si-act-watch
contract: 0476e35e6e275db5
---

# tool si.act.watch

a public entity: a watched identity, with its monitor armed.

[figure: Over MCP, si.act.watch takes WatchInput and returns a card whose body is WatchedIdentity.]

a watched identity, with its monitor armed. The call needs the act grant at the brand rung.



| | |
|---|---|
| input | [WatchInput](/concepts/watchinput) |
| result | a card whose body is [WatchedIdentity](/concepts/watchedidentity) |
| read-only | no |
| destructive | yes |
| card address | `ui://scale-intelligence/cards/WatchedIdentity` |
| HTTP route | [`/v1/act/watch`](/reference/act/watch) |





| field | type | required | note |
|---|---|---|---|
| `entity` | `id` | yes |  |


---
title: "tool si.act.watch_site"
description: "a `WatchSiteInput`: the watch, ready or not ready; for a preview, the pages it would read and the changes it would have raised over the window."
section: reference
address: /reference/tools/si-act-watch_site
contract: 0476e35e6e275db5
---

# tool si.act.watch_site

a `WatchSiteInput`: the watch, ready or not ready; for a preview, the pages it would read and the changes it would have raised over the window.

[figure: Over MCP, si.act.watch_site takes WatchSiteInput and returns a card whose body is SiteWatch.]

the watch, ready or not ready; for a preview, the pages it would read and the changes it would have raised over the window. The call needs the act grant at the brand rung.



| | |
|---|---|
| input | [WatchSiteInput](/concepts/watchsiteinput) |
| result | a card whose body is [SiteWatch](/concepts/sitewatch) |
| read-only | no |
| destructive | yes |
| card address | `ui://scale-intelligence/cards/SiteWatch` |
| HTTP route | [`/v1/act/watch_site`](/reference/act/watch_site) |





| field | type | required | note |
|---|---|---|---|
| `watch` | [SiteWatch](/concepts/sitewatch) | yes |  |
| `flow` | `one of write \| preview \| arm \| disarm` | yes |  |


---
title: "tool si.act.webhook"
description: "the address, what to be told about, and a secret to sign with: the row."
section: reference
address: /reference/tools/si-act-webhook
contract: 0476e35e6e275db5
---

# tool si.act.webhook

the address, what to be told about, and a secret to sign with: the row.

[figure: Over MCP, si.act.webhook takes WebhookInput and returns a card whose body is Telling.]

the row. The call needs the act grant at the tenant rung.



| | |
|---|---|
| input | [WebhookInput](/concepts/webhookinput) |
| result | a card whose body is [Telling](/concepts/telling) |
| read-only | no |
| destructive | yes |
| card address | `ui://scale-intelligence/cards/Telling` |
| HTTP route | [`/v1/act/webhook`](/reference/act/webhook) |





| field | type | required | note |
|---|---|---|---|
| `telling` | [Telling](/concepts/telling) | yes |  |


---
title: "tool si.act.weigh"
description: "a hypothesis, and a fact or a test's reading: the hypothesis with the evidence attached and its standing recomputed against its bar."
section: reference
address: /reference/tools/si-act-weigh
contract: 0476e35e6e275db5
---

# tool si.act.weigh

a hypothesis, and a fact or a test's reading: the hypothesis with the evidence attached and its standing recomputed against its bar.

[figure: Over MCP, si.act.weigh takes WeighInput and returns a card whose body is Hypothesis.]

the hypothesis with the evidence attached and its standing recomputed against its bar. The call needs the act grant at the strategy rung.



| | |
|---|---|
| input | [WeighInput](/concepts/weighinput) |
| result | a card whose body is [Hypothesis](/concepts/hypothesis) |
| read-only | no |
| destructive | yes |
| card address | `ui://scale-intelligence/cards/Hypothesis` |
| HTTP route | [`/v1/act/weigh`](/reference/act/weigh) |





| field | type | required | note |
|---|---|---|---|
| `hypothesis` | `id` | yes |  |
| `for` | [EvidenceRef](/concepts/evidenceref) | no |  |
| `against` | [EvidenceRef](/concepts/evidenceref) | no |  |


---
title: "tool si.act.withdraw"
description: "a publishing: the publishing, withdrawn."
section: reference
address: /reference/tools/si-act-withdraw
contract: 0476e35e6e275db5
---

# tool si.act.withdraw

a publishing: the publishing, withdrawn.

[figure: Over MCP, si.act.withdraw takes WithdrawInput and returns a card whose body is Publishing.]

the publishing, withdrawn. The call needs the act grant at the brand rung.



| | |
|---|---|
| input | [WithdrawInput](/concepts/withdrawinput) |
| result | a card whose body is [Publishing](/concepts/publishing) |
| read-only | no |
| destructive | yes |
| card address | `ui://scale-intelligence/cards/Publishing` |
| HTTP route | [`/v1/act/withdraw`](/reference/act/withdraw) |





| field | type | required | note |
|---|---|---|---|
| `publishing` | `id` | yes |  |
| `reason` | `text` | yes |  |


---
title: "tool si.act.workflow"
description: "its steps and what starts it: the workflow, and for a preview what it would have done over history, acting on nothing."
section: reference
address: /reference/tools/si-act-workflow
contract: 0476e35e6e275db5
---

# tool si.act.workflow

its steps and what starts it: the workflow, and for a preview what it would have done over history, acting on nothing.

[figure: Over MCP, si.act.workflow takes WorkflowInput and returns a card whose body is WorkflowAnswer.]

the workflow, and for a preview what it would have done over history, acting on nothing. The call needs the act grant at the strategy rung.



| | |
|---|---|
| input | [WorkflowInput](/concepts/workflowinput) |
| result | a card whose body is [WorkflowAnswer](/concepts/workflowanswer) |
| read-only | no |
| destructive | yes |
| card address | `ui://scale-intelligence/cards/WorkflowAnswer` |
| HTTP route | [`/v1/act/workflow`](/reference/act/workflow) |





| field | type | required | note |
|---|---|---|---|
| `workflow` | [Workflow](/concepts/workflow) | yes |  |
| `do` | `one of write \| preview \| arm` | yes |  |


---
title: "tool si.ask.facts"
description: "a unit or a population, the date it was true, and the date we knew it, as two parameters."
section: reference
address: /reference/tools/si-ask-facts
contract: 0476e35e6e275db5
---

# tool si.ask.facts

a unit or a population, the date it was true, and the date we knew it, as two parameters.

[figure: Over MCP, si.ask.facts takes FactsInput and returns a card whose body is FactsAnswer.]

the facts, and the tier that gave them. The call needs the ask grant at the strategy rung.



| | |
|---|---|
| input | [FactsInput](/concepts/factsinput) |
| result | a card whose body is [FactsAnswer](/concepts/factsanswer) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/FactsAnswer` |
| HTTP route | [`/v1/ask/facts`](/reference/ask/facts) |





| field | type | required | note |
|---|---|---|---|
| `unit` | [UnitRef](/concepts/unitref) | no |  |
| `population` | [Predicate](/concepts/predicate) | no |  |
| `attributes` | `[text]` | no |  |


---
title: "tool si.ask.get_content"
description: "a `ContentRequest`: a `ContentResponse`, the page in bronze."
section: reference
address: /reference/tools/si-ask-get_content
contract: 0476e35e6e275db5
---

# tool si.ask.get_content

a `ContentRequest`: a `ContentResponse`, the page in bronze.

[figure: Over MCP, si.ask.get_content takes ContentRequest and returns a card whose body is ContentResponse.]

a `ContentResponse`, the page in bronze. The call needs the ask grant at the strategy rung.



| | |
|---|---|
| input | [ContentRequest](/concepts/contentrequest) |
| result | a card whose body is [ContentResponse](/concepts/contentresponse) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/ContentResponse` |
| HTTP route | [`/v1/ask/get_content`](/reference/ask/get_content) |





| field | type | required | note |
|---|---|---|---|
| `address` | `text` | yes |  |
| `returns` | `[one of article \| html \| markdown \| text \| links \| metadata \| stylesheets \| scripts \| images \| screenshot \| pdf \| network events]` | yes | article is the main content with its title, author, published time and language, as CrawlKit's extractor returns it |
| `filter` | [ResourceFilter](/concepts/resourcefilter) | yes |  |
| `as_identity` | `id` | no | a held identity, lent by a grant: its cookie jar, session token, access token or API key |
| `proxy_policy` | [ProxyPolicy](/concepts/proxypolicy) | no |  |
| `wait_for` | `text` | no | a selector or a time |
| `cache_for` | `duration` | no |  |
| `credit_cells` | `[id]` | no |  |


---
title: "tool si.ask.groups"
description: "a scope, the two dates, and the resolution of the cut: the cluster response cards: each group with the share each layer of likeness contributed, its top communities, words and domains, its size and trend by month, and the proxies that placed its members."
section: reference
address: /reference/tools/si-ask-groups
contract: 0476e35e6e275db5
---

# tool si.ask.groups

a scope, the two dates, and the resolution of the cut: the cluster response cards: each group with the share each layer of likeness contributed, its top communities, words and domains, its size and trend by month, and the proxies that placed its members.

[figure: Over MCP, si.ask.groups takes GroupsInput and returns a card whose body is [ClusterCard].]

the cluster response cards: each group with the share each layer of likeness contributed, its top communities, words and domains, its size and trend by month, and the proxies that placed its members. The call needs the ask grant at the strategy rung.



| | |
|---|---|
| input | [GroupsInput](/concepts/groupsinput) |
| result | a card whose body is [ClusterCard](/concepts/clustercard) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/ClusterCard` |
| HTTP route | [`/v1/ask/groups`](/reference/ask/groups) |





| field | type | required | note |
|---|---|---|---|
| `scope` | [Predicate](/concepts/predicate) | yes |  |
| `resolution` | `share` | yes |  |


---
title: "tool si.ask.judge_fit"
description: "Judges one entity against a buyer profile, and against a brand whose offerings' fit is in question: The answer gives the fit with each criterion and its highlights, the temperature with its reason, and the verdict."
section: reference
address: /reference/tools/si-ask-judge_fit
contract: 0476e35e6e275db5
---

# tool si.ask.judge_fit

Judges one entity against a buyer profile, and against a brand whose offerings' fit is in question: The answer gives the fit with each criterion and its highlights, the temperature with its reason, and the verdict.

[figure: Over MCP, si.ask.judge_fit takes JudgeFitInput and returns a card whose body is BuyerFitVerdict.]

The answer gives the fit with each criterion and its highlights, the temperature with its reason, and the verdict. It makes no lead. The call needs the ask grant at the strategy rung.



| | |
|---|---|
| input | [JudgeFitInput](/concepts/judgefitinput) |
| result | a card whose body is [BuyerFitVerdict](/concepts/buyerfitverdict) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/BuyerFitVerdict` |
| HTTP route | [`/v1/ask/judge_fit`](/reference/ask/judge_fit) |





| field | type | required | note |
|---|---|---|---|
| `kind_of_buyer` | `id` | yes |  |
| `entity` | `id` | yes |  |
| `brand` | `id` | no |  |


---
title: "tool si.ask.keep_question"
description: "the question and its scope: a saved question."
section: reference
address: /reference/tools/si-ask-keep_question
contract: 0476e35e6e275db5
---

# tool si.ask.keep_question

the question and its scope: a saved question.

[figure: Over MCP, si.ask.keep_question takes KeepQuestionInput and returns a card whose body is SavedQuestion.]

a saved question. The call needs the ask grant at the user rung.



| | |
|---|---|
| input | [KeepQuestionInput](/concepts/keepquestioninput) |
| result | a card whose body is [SavedQuestion](/concepts/savedquestion) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/SavedQuestion` |
| HTTP route | [`/v1/ask/keep_question`](/reference/ask/keep_question) |





| field | type | required | note |
|---|---|---|---|
| `question` | [SavedQuestion](/concepts/savedquestion) | yes |  |


---
title: "tool si.ask.local"
description: "a question in one of the ask tools' owning types, over the files the app may read: the card, answered by the app's own engine over its tenant's files, with the same foot."
section: reference
address: /reference/tools/si-ask-local
contract: 0476e35e6e275db5
---

# tool si.ask.local

a question in one of the ask tools' owning types, over the files the app may read: the card, answered by the app's own engine over its tenant's files, with the same foot.

[figure: Over MCP, si.ask.local takes LocalInput and returns a card whose body is Card.]

the card, answered by the app's own engine over its tenant's files, with the same foot. The call needs the ask grant at the strategy rung.



| | |
|---|---|
| input | [LocalInput](/concepts/localinput) |
| result | a card whose body is [Card](/concepts/card) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/Card` |
| HTTP route | [`/v1/ask/local`](/reference/ask/local) |





| field | type | required | note |
|---|---|---|---|
| `tool` | `text` | yes | an ask tool |
| `input` | `json` | yes | the serialisation of that tool's input |


---
title: "tool si.ask.neighbours"
description: "an entity, one kind of connection, and the two dates: the members, one hop away, and whether the cap was reached."
section: reference
address: /reference/tools/si-ask-neighbours
contract: 0476e35e6e275db5
---

# tool si.ask.neighbours

an entity, one kind of connection, and the two dates: the members, one hop away, and whether the cap was reached.

[figure: Over MCP, si.ask.neighbours takes NeighboursInput and returns a card whose body is NeighboursAnswer.]

the members, one hop away, and whether the cap was reached. The call needs the ask grant at the strategy rung.



| | |
|---|---|
| input | [NeighboursInput](/concepts/neighboursinput) |
| result | a card whose body is [NeighboursAnswer](/concepts/neighboursanswer) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/NeighboursAnswer` |
| HTTP route | [`/v1/ask/neighbours`](/reference/ask/neighbours) |





| field | type | required | note |
|---|---|---|---|
| `entity` | `id` | yes |  |
| `kind` | [KindOfConnection](/concepts/kindofconnection) | yes |  |
| `role` | `text` | no |  |


---
title: "tool si.ask.preview"
description: "a predicate or its hash, the place, the window, the speeds wanted, and the caller with the surface it calls from: the typed answer of section 2.3, as it fills."
section: reference
address: /reference/tools/si-ask-preview
contract: 0476e35e6e275db5
---

# tool si.ask.preview

a predicate or its hash, the place, the window, the speeds wanted, and the caller with the surface it calls from: the typed answer of section 2.3, as it fills.

[figure: Over MCP, si.ask.preview takes PreviewInput and returns a card whose body is PreviewAnswer.]

the typed answer of section 2.3, as it fills. The call needs the ask grant at the strategy rung.



| | |
|---|---|
| input | [PreviewInput](/concepts/previewinput) |
| result | a card whose body is [PreviewAnswer](/concepts/previewanswer) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/PreviewAnswer` |
| HTTP route | [`/v1/ask/preview`](/reference/ask/preview) |





| field | type | required | note |
|---|---|---|---|
| `predicate` | [Predicate](/concepts/predicate) | no |  |
| `predicate_hash` | `hash` | no |  |
| `place` | [PlaceARunsAt](/concepts/placearunsat) | yes |  |
| `window` | [Window](/concepts/window) | yes |  |
| `speeds` | `[one of instant \| the last seven days \| the whole record]` | yes |  |


---
title: "tool si.ask.propose_template"
description: "a `ProposeTemplateInput`: a draft template with fields and evidence spans for the person to confirm."
section: reference
address: /reference/tools/si-ask-propose_template
contract: 0476e35e6e275db5
---

# tool si.ask.propose_template

a `ProposeTemplateInput`: a draft template with fields and evidence spans for the person to confirm.

[figure: Over MCP, si.ask.propose_template takes ProposeTemplateInput and returns a card whose body is ExtractionTemplate.]

a draft template with fields and evidence spans for the person to confirm. The call needs the ask grant at the strategy rung.



| | |
|---|---|
| input | [ProposeTemplateInput](/concepts/proposetemplateinput) |
| result | a card whose body is [ExtractionTemplate](/concepts/extractiontemplate) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/ExtractionTemplate` |
| HTTP route | [`/v1/ask/propose_template`](/reference/ask/propose_template) |





| field | type | required | note |
|---|---|---|---|
| `address` | `text` | yes |  |
| `page_kind` | `one of listing \| detail \| feed \| table \| search results \| infinite scroll \| document \| API response` | yes |  |
| `marked` | `[text]` | yes | the values the person pointed at |
| `as_identity` | `id` | no |  |


---
title: "tool si.ask.read_source"
description: "the installed connector, the kind, a cursor: a page of source objects, the next cursor, the cells credited."
section: reference
address: /reference/tools/si-ask-read_source
contract: 0476e35e6e275db5
---

# tool si.ask.read_source

the installed connector, the kind, a cursor: a page of source objects, the next cursor, the cells credited.

[figure: Over MCP, si.ask.read_source takes ReadSourceInput and returns a card whose body is ReadSourcePage.]

a page of source objects, the next cursor, the cells credited. The call needs the ask grant at the strategy rung.



| | |
|---|---|
| input | [ReadSourceInput](/concepts/readsourceinput) |
| result | a card whose body is [ReadSourcePage](/concepts/readsourcepage) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/ReadSourcePage` |
| HTTP route | [`/v1/ask/read_source`](/reference/ask/read_source) |





| field | type | required | note |
|---|---|---|---|
| `installed_connector` | `id` | yes |  |
| `kind_of_reading` | `id` | yes |  |
| `cursor` | `text` | no |  |
| `credit_cells` | `[id]` | no |  |


---
title: "tool si.ask.saved_view"
description: "the view. Or the view and a caller: the definition. Or its rows, with when they were built. The call needs the ask grant at the strategy rung."
section: reference
address: /reference/tools/si-ask-saved_view
contract: 0476e35e6e275db5
---

# tool si.ask.saved_view

the view. Or the view and a caller: the definition. Or its rows, with when they were built. The call needs the ask grant at the strategy rung.

[figure: Over MCP, si.ask.saved_view takes SavedViewInput and returns a card whose body is SavedViewAnswer.]

the definition. Or its rows, with when they were built. The call needs the ask grant at the strategy rung.



| | |
|---|---|
| input | [SavedViewInput](/concepts/savedviewinput) |
| result | a card whose body is [SavedViewAnswer](/concepts/savedviewanswer) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/SavedViewAnswer` |
| HTTP route | [`/v1/ask/saved_view`](/reference/ask/saved_view) |





| field | type | required | note |
|---|---|---|---|
| `view` | [SavedView](/concepts/savedview) | no | to keep |
| `read` | `id` | no | to read its rows |
| `page` | `count` | no |  |


---
title: "tool si.ask.scrape"
description: "a `ScrapeRequest`: a `ScrapeResult`, the rows as source objects with their evidence spans."
section: reference
address: /reference/tools/si-ask-scrape
contract: 0476e35e6e275db5
---

# tool si.ask.scrape

a `ScrapeRequest`: a `ScrapeResult`, the rows as source objects with their evidence spans.

[figure: Over MCP, si.ask.scrape takes ScrapeRequest and returns a card whose body is ScrapeResult.]

a `ScrapeResult`, the rows as source objects with their evidence spans. The call needs the ask grant at the strategy rung.



| | |
|---|---|
| input | [ScrapeRequest](/concepts/scraperequest) |
| result | a card whose body is [ScrapeResult](/concepts/scraperesult) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/ScrapeResult` |
| HTTP route | [`/v1/ask/scrape`](/reference/ask/scrape) |





| field | type | required | note |
|---|---|---|---|
| `template` | `id` | no | an extraction template; any of its parts may be overridden below |
| `scope` | [CrawlScope](/concepts/crawlscope) | no | required when no template |
| `fields` | [FieldSpec](/concepts/fieldspec) | no | declared selectors |
| `schema` | `json` | no | for the model-assisted reader, every value with its evidence span or refused |
| `source_object` | [SourceObject](/concepts/sourceobject) | yes | declared inline for one scrape, or a registered row |
| `mapping` | [Mapping](/concepts/mapping) | no |  |
| `filter` | [ResourceFilter](/concepts/resourcefilter) | yes |  |
| `as_identity` | `id` | no |  |
| `proxy_policy` | [ProxyPolicy](/concepts/proxypolicy) | no |  |
| `credit_cells` | `[id]` | no |  |
| `asked_by` | `text` | no | who asked for the run, as the caller's kind, or the crawler for an address a walk found; the beat takes what a person or the agent asked before the crawler's own discoveries, oldest first within each |


---
title: "tool si.ask.search"
description: "a `SearchRequest`: `SearchResult` rows, streamed as engines answer, credited to cells."
section: reference
address: /reference/tools/si-ask-search
contract: 0476e35e6e275db5
---

# tool si.ask.search

a `SearchRequest`: `SearchResult` rows, streamed as engines answer, credited to cells.

[figure: Over MCP, si.ask.search takes SearchRequest and returns a card whose body is [SearchResult].]

`SearchResult` rows, streamed as engines answer, credited to cells. The call needs the ask grant at the strategy rung.



| | |
|---|---|
| input | [SearchRequest](/concepts/searchrequest) |
| result | a card whose body is [SearchResult](/concepts/searchresult) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/SearchResult` |
| HTTP route | [`/v1/ask/search`](/reference/ask/search) |





| field | type | required | note |
|---|---|---|---|
| `query` | `text` | yes |  |
| `engines` | `[text]` | no | empty means the rows' default set |
| `categories` | `[text]` | no | general, news, science, social, code, images, videos, files, maps |
| `time_range` | [Window](/concepts/window) | no |  |
| `language` | `text` | no |  |
| `safe_search` | `one of off \| moderate \| strict` | yes |  |
| `count` | `count` | yes |  |
| `page` | `count` | yes |  |
| `as_identity` | `id` | no | a held identity, lent by a grant |
| `credit_cells` | `[id]` | no |  |


---
title: "tool si.ask.semantic_search"
description: "a text or a subject's vector, the model, a floor and a population: the units above the floor."
section: reference
address: /reference/tools/si-ask-semantic_search
contract: 0476e35e6e275db5
---

# tool si.ask.semantic_search

a text or a subject's vector, the model, a floor and a population: the units above the floor.

[figure: Over MCP, si.ask.semantic_search takes SemanticSearchInput and returns a card whose body is SemanticSearchAnswer.]

the units above the floor. With them: the model, the floor, the measured recall of quantized embeddings, and the tier. The call needs the ask grant at the strategy rung.



| | |
|---|---|
| input | [SemanticSearchInput](/concepts/semanticsearchinput) |
| result | a card whose body is [SemanticSearchAnswer](/concepts/semanticsearchanswer) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/SemanticSearchAnswer` |
| HTTP route | [`/v1/ask/semantic_search`](/reference/ask/semantic_search) |





| field | type | required | note |
|---|---|---|---|
| `text` | `text` | no |  |
| `subject` | [UnitRef](/concepts/unitref) | no |  |
| `model` | [Model](/concepts/model) | yes |  |
| `floor` | `share` | yes |  |
| `population` | [Predicate](/concepts/predicate) | yes |  |


---
title: "tool si.ask.sql"
description: "a query, in a strategy: rows, with how many and whether a bound was reached."
section: reference
address: /reference/tools/si-ask-sql
contract: 0476e35e6e275db5
---

# tool si.ask.sql

a query, in a strategy: rows, with how many and whether a bound was reached.

[figure: Over MCP, si.ask.sql takes SqlInput and returns a card whose body is SqlAnswer.]

rows, with how many and whether a bound was reached. The call needs the ask grant at the strategy rung.



| | |
|---|---|
| input | [SqlInput](/concepts/sqlinput) |
| result | a card whose body is [SqlAnswer](/concepts/sqlanswer) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/SqlAnswer` |
| HTTP route | [`/v1/ask/sql`](/reference/ask/sql) |





| field | type | required | note |
|---|---|---|---|
| `query` | `text` | yes |  |
| `strategy` | `id` | yes |  |
| `bound` | `count` | no |  |


---
title: "tool si.economics.benchmarks"
description: "a driver, and a population or a buyer profile: the benchmarks that apply, each with its interval, population, period, source and what its rights allow."
section: reference
address: /reference/tools/si-economics-benchmarks
contract: 0476e35e6e275db5
---

# tool si.economics.benchmarks

a driver, and a population or a buyer profile: the benchmarks that apply, each with its interval, population, period, source and what its rights allow.

[figure: Over MCP, si.economics.benchmarks takes BenchmarksInput and returns a card whose body is [Benchmark].]

the benchmarks that apply, each with its interval, population, period, source and what its rights allow. The call needs the read grant at the tenant rung.



| | |
|---|---|
| input | [BenchmarksInput](/concepts/benchmarksinput) |
| result | a card whose body is [Benchmark](/concepts/benchmark) |
| read-only | no |
| destructive | no |
| card address | `ui://scale-intelligence/cards/Benchmark` |
| HTTP route | [`/v1/economics/benchmarks`](/reference/economics/benchmarks) |





| field | type | required | note |
|---|---|---|---|
| `driver` | [KindOfMeasure](/concepts/kindofmeasure) | yes |  |
| `kind_of_buyer` | `text` | no |  |


---
title: "tool si.economics.estimate"
description: "`EstimateReturnInput`: the buyer (an entity, a lead, a buyer profile or a session), the offering or tier, the stated numbers, and whether to simulate: a `Card` whose body is a `FrameOfASale`."
section: reference
address: /reference/tools/si-economics-estimate
contract: 0476e35e6e275db5
---

# tool si.economics.estimate

`EstimateReturnInput`: the buyer (an entity, a lead, a buyer profile or a session), the offering or tier, the stated numbers, and whether to simulate: a `Card` whose body is a `FrameOfASale`.

[figure: Over MCP, si.economics.estimate takes EstimateReturnInput and returns a card whose body is SaleFrame.]

a `Card` whose body is a `FrameOfASale`. The call needs the read grant at the tenant rung.



| | |
|---|---|
| input | [EstimateReturnInput](/concepts/estimatereturninput) |
| result | a card whose body is [SaleFrame](/concepts/saleframe) |
| read-only | no |
| destructive | no |
| card address | `ui://scale-intelligence/cards/SaleFrame` |
| HTTP route | [`/v1/economics/estimate`](/reference/economics/estimate) |





| field | type | required | note |
|---|---|---|---|
| `buyer` | [UnitRef](/concepts/unitref) | yes |  |
| `offering` | `id` | no |  |
| `tier` | `text` | no |  |
| `stated` | `{text:json}` | no | driver name to value, each written as a stated number before the estimate reads it |
| `simulate` | `bool` | yes |  |


---
title: "tool si.economics.ladder"
description: "nothing, or a version: the price ladder in force with its study."
section: reference
address: /reference/tools/si-economics-ladder
contract: 0476e35e6e275db5
---

# tool si.economics.ladder

nothing, or a version: the price ladder in force with its study.

[figure: Over MCP, si.economics.ladder takes LadderInput and returns a card whose body is PriceLadder.]

the price ladder in force with its study. The call needs the read grant at the tenant rung.



| | |
|---|---|
| input | [LadderInput](/concepts/ladderinput) |
| result | a card whose body is [PriceLadder](/concepts/priceladder) |
| read-only | no |
| destructive | no |
| card address | `ui://scale-intelligence/cards/PriceLadder` |
| HTTP route | [`/v1/economics/ladder`](/reference/economics/ladder) |





| field | type | required | note |
|---|---|---|---|
| `version` | `count` | no |  |


---
title: "tool si.economics.models"
description: "a vertical, a segment or a buyer profile: the business models that apply, each with its readiness, its drivers and its outputs."
section: reference
address: /reference/tools/si-economics-models
contract: 0476e35e6e275db5
---

# tool si.economics.models

a vertical, a segment or a buyer profile: the business models that apply, each with its readiness, its drivers and its outputs.

[figure: Over MCP, si.economics.models takes ModelsInput and returns a card whose body is [BusinessModel].]

the business models that apply, each with its readiness, its drivers and its outputs. The call needs the read grant at the tenant rung.



| | |
|---|---|
| input | [ModelsInput](/concepts/modelsinput) |
| result | a card whose body is [BusinessModel](/concepts/businessmodel) |
| read-only | no |
| destructive | no |
| card address | `ui://scale-intelligence/cards/BusinessModel` |
| HTTP route | [`/v1/economics/models`](/reference/economics/models) |





| field | type | required | note |
|---|---|---|---|
| `vertical` | `id` | no |  |
| `segment` | `id` | no |  |
| `kind_of_buyer` | `text` | no | the buyer profile's name |


---
title: "tool si.economics.offer"
description: "`ReadingOfferedInput`: the buyer profile, the model, the drivers to ask: the reading offered, ready or not ready with the reason, and its page's address."
section: reference
address: /reference/tools/si-economics-offer
contract: 0476e35e6e275db5
---

# tool si.economics.offer

`ReadingOfferedInput`: the buyer profile, the model, the drivers to ask: the reading offered, ready or not ready with the reason, and its page's address.

[figure: Over MCP, si.economics.offer takes ReadingOfferedInput and returns a card whose body is ReadingOffered.]

the reading offered, ready or not ready with the reason, and its page's address. The call needs the act grant at the brand rung.



| | |
|---|---|
| input | [ReadingOfferedInput](/concepts/readingofferedinput) |
| result | a card whose body is [ReadingOffered](/concepts/readingoffered) |
| read-only | no |
| destructive | no |
| card address | `ui://scale-intelligence/cards/ReadingOffered` |
| HTTP route | [`/v1/economics/offer`](/reference/economics/offer) |





| field | type | required | note |
|---|---|---|---|
| `kind_of_buyer` | `id` | yes |  |
| `business_model` | `id` | yes |  |
| `asks` | [KindOfMeasure](/concepts/kindofmeasure) | yes |  |


---
title: "tool si.economics.study"
description: "`PricingStudyInput`: the methods to run, the buyer profiles, the rivals' window: the study as a fact and its candidate ladders as a set of options."
section: reference
address: /reference/tools/si-economics-study
contract: 0476e35e6e275db5
---

# tool si.economics.study

`PricingStudyInput`: the methods to run, the buyer profiles, the rivals' window: the study as a fact and its candidate ladders as a set of options.

[figure: Over MCP, si.economics.study takes PricingStudyInput and returns a card whose body is PricingStudy.]

the study as a fact and its candidate ladders as a set of options. The call needs the act grant at the platform rung.



| | |
|---|---|
| input | [PricingStudyInput](/concepts/pricingstudyinput) |
| result | a card whose body is [PricingStudy](/concepts/pricingstudy) |
| read-only | no |
| destructive | no |
| card address | `ui://scale-intelligence/cards/PricingStudy` |
| HTTP route | [`/v1/economics/study`](/reference/economics/study) |





| field | type | required | note |
|---|---|---|---|
| `methods` | [Method](/concepts/method) | yes |  |
| `kinds_of_buyer` | `[id]` | yes |  |
| `window` | [Window](/concepts/window) | yes |  |


---
title: "tool si.files.download"
description: "a file's pointer from a task or a document, and where in the workspace to put it: progress by bytes moved of bytes in all, then the path inside the workspace."
section: reference
address: /reference/tools/si-files-download
contract: 0476e35e6e275db5
---

# tool si.files.download

a file's pointer from a task or a document, and where in the workspace to put it: progress by bytes moved of bytes in all, then the path inside the workspace.

[figure: Over MCP, si.files.download takes DownloadInput and returns a card whose body is FileTransfer.]

progress by bytes moved of bytes in all, then the path inside the workspace. The call needs the files grant at the user rung.



| | |
|---|---|
| input | [DownloadInput](/concepts/downloadinput) |
| result | a card whose body is [FileTransfer](/concepts/filetransfer) |
| read-only | no |
| destructive | no |
| card address | `ui://scale-intelligence/cards/FileTransfer` |
| HTTP route | [`/v1/files/download`](/reference/files/download) |





| field | type | required | note |
|---|---|---|---|
| `pointer` | `id` | yes |  |
| `into` | `text` | no |  |


---
title: "tool si.files.list"
description: "a path inside the workspace, or nothing: the files with their sizes, kinds and when they were written."
section: reference
address: /reference/tools/si-files-list
contract: 0476e35e6e275db5
---

# tool si.files.list

a path inside the workspace, or nothing: the files with their sizes, kinds and when they were written.

[figure: Over MCP, si.files.list takes Nothing and returns a card whose body is FileList.]

the files with their sizes, kinds and when they were written. The call needs the files grant at the user rung.



| | |
|---|---|
| input | [Nothing](/concepts/nothing) |
| result | a card whose body is [FileList](/concepts/filelist) |
| read-only | no |
| destructive | no |
| card address | `ui://scale-intelligence/cards/FileList` |
| HTTP route | [`/v1/files/list`](/reference/files/list) |


---
title: "tool si.files.upload"
description: "a path inside the workspace, and what the file is for: progress, then the pointer the platform kept."
section: reference
address: /reference/tools/si-files-upload
contract: 0476e35e6e275db5
---

# tool si.files.upload

a path inside the workspace, and what the file is for: progress, then the pointer the platform kept.

[figure: Over MCP, si.files.upload takes UploadInput and returns a card whose body is FileTransfer.]

progress, then the pointer the platform kept. The call needs the files grant at the user rung.



| | |
|---|---|
| input | [UploadInput](/concepts/uploadinput) |
| result | a card whose body is [FileTransfer](/concepts/filetransfer) |
| read-only | no |
| destructive | no |
| card address | `ui://scale-intelligence/cards/FileTransfer` |
| HTTP route | [`/v1/files/upload`](/reference/files/upload) |





| field | type | required | note |
|---|---|---|---|
| `path` | `text` | yes |  |
| `kind` | [UserProvidedContentKind](/concepts/userprovidedcontentkind) | yes |  |


---
title: "tool si.files.workspace"
description: "nothing, or a folder to make the workspace: the workspace folder, and every act the app made in it on the ledger."
section: reference
address: /reference/tools/si-files-workspace
contract: 0476e35e6e275db5
---

# tool si.files.workspace

nothing, or a folder to make the workspace: the workspace folder, and every act the app made in it on the ledger.

[figure: Over MCP, si.files.workspace takes Nothing and returns a card whose body is Workspace.]

the workspace folder, and every act the app made in it on the ledger. The call needs the files grant at the user rung.



| | |
|---|---|
| input | [Nothing](/concepts/nothing) |
| result | a card whose body is [Workspace](/concepts/workspace) |
| read-only | no |
| destructive | no |
| card address | `ui://scale-intelligence/cards/Workspace` |
| HTTP route | [`/v1/files/workspace`](/reference/files/workspace) |


---
title: "tool si.harness.delegate"
description: "words, in a strategy: response cards, as they come, and a task where the work goes on."
section: reference
address: /reference/tools/si-harness-delegate
contract: 0476e35e6e275db5
---

# tool si.harness.delegate

words, in a strategy: response cards, as they come, and a task where the work goes on.

[figure: Over MCP, si.harness.delegate takes DelegateInput and returns a card whose body is Task.]

response cards, as they come, and a task where the work goes on. The call needs the work grant at the strategy rung.



| | |
|---|---|
| input | [DelegateInput](/concepts/delegateinput) |
| result | a card whose body is [Task](/concepts/task) |
| read-only | no |
| destructive | no |
| card address | `ui://scale-intelligence/cards/Task` |
| HTTP route | [`/v1/harness/delegate`](/reference/harness/delegate) |





| field | type | required | note |
|---|---|---|---|
| `words` | `text` | yes |  |
| `about` | [UnitRef](/concepts/unitref) | no |  |
| `strategy` | `id` | no |  |


---
title: "tool si.read.attributes"
description: "a population and, where wanted, a window: the attributes its units carry, each with its plain name, the units that carry it, the value type read and up to three examples, most carried first, with the units read and in, and the partial answer when the budget ran out."
section: reference
address: /reference/tools/si-read-attributes
contract: 0476e35e6e275db5
---

# tool si.read.attributes

a population and, where wanted, a window: the attributes its units carry, each with its plain name, the units that carry it, the value type read and up to three examples, most carried first, with the units read and in, and the partial answer when the budget ran out.

[figure: Over MCP, si.read.attributes takes AttributesInput and returns a card whose body is PopulationAttributes.]

the attributes its units carry, each with its plain name, the units that carry it, the value type read and up to three examples, most carried first, with the units read and in, and the partial answer when the budget ran out. The call needs the read grant at the strategy rung.



| | |
|---|---|
| input | [AttributesInput](/concepts/attributesinput) |
| result | a card whose body is [PopulationAttributes](/concepts/populationattributes) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/PopulationAttributes` |
| HTTP route | [`/v1/read/attributes`](/reference/read/attributes) |





| field | type | required | note |
|---|---|---|---|
| `population` | [Population](/concepts/population) | yes |  |
| `window` | [Window](/concepts/window) | no | the units read; the whole record when absent |


---
title: "tool si.read.audience_map"
description: "a brand, two facets or a facet and a community, the window: the shared subjects, the share, the lift, the negative control that bounds it, and the size as bounds."
section: reference
address: /reference/tools/si-read-audience_map
contract: 0476e35e6e275db5
---

# tool si.read.audience_map

a brand, two facets or a facet and a community, the window: the shared subjects, the share, the lift, the negative control that bounds it, and the size as bounds.

[figure: Over MCP, si.read.audience_map takes AudienceMapInput and returns a card whose body is AudienceMapCell.]

the shared subjects, the share, the lift, the negative control that bounds it, and the size as bounds. The call needs the read grant at the brand rung.



| | |
|---|---|
| input | [AudienceMapInput](/concepts/audiencemapinput) |
| result | a card whose body is [AudienceMapCell](/concepts/audiencemapcell) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/AudienceMapCell` |
| HTTP route | [`/v1/read/audience_map`](/reference/read/audience_map) |





| field | type | required | note |
|---|---|---|---|
| `brand` | `id` | yes |  |
| `first` | `id` | yes |  |
| `second` | `id` | yes |  |
| `window` | [Window](/concepts/window) | yes |  |
| `adult` | `bool` | no | when true, the rooms marked adult count in the crossing; left out by default |


---
title: "tool si.read.basket"
description: "the basket, and one subject, a set of subjects, a scope predicate or a cut into groups, with the window: the basket reading as a fact: memberships with their scale of association and likelihood for one subject; population readings and co-membership for a set; proxy against group with lift and control for groups."
section: reference
address: /reference/tools/si-read-basket
contract: 0476e35e6e275db5
---

# tool si.read.basket

the basket, and one subject, a set of subjects, a scope predicate or a cut into groups, with the window: the basket reading as a fact: memberships with their scale of association and likelihood for one subject; population readings and co-membership for a set; proxy against group with lift and control for groups.

[figure: Over MCP, si.read.basket takes BasketReadInput and returns a card whose body is BasketReading.]

the basket reading as a fact: memberships with their scale of association and likelihood for one subject; population readings and co-membership for a set; proxy against group with lift and control for groups. The call needs the read grant at the strategy rung.



| | |
|---|---|
| input | [BasketReadInput](/concepts/basketreadinput) |
| result | a card whose body is [BasketReading](/concepts/basketreading) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/BasketReading` |
| HTTP route | [`/v1/read/basket`](/reference/read/basket) |





| field | type | required | note |
|---|---|---|---|
| `basket` | `id` | yes |  |
| `subject` | `id` | no | one subject |
| `subjects` | `[id]` | no | a set, under the size bound |
| `scope` | [Predicate](/concepts/predicate) | no | a population by predicate |
| `resolution` | `share` | no | a cut into groups at this resolution |
| `window` | [Window](/concepts/window) | no |  |


---
title: "tool si.read.board"
description: "the board and a period: the board with every tile's numbers, each with its basis and its population."
section: reference
address: /reference/tools/si-read-board
contract: 0476e35e6e275db5
---

# tool si.read.board

the board and a period: the board with every tile's numbers, each with its basis and its population.

[figure: Over MCP, si.read.board takes BoardReadInput and returns a card whose body is BoardAnswer.]

the board with every tile's numbers, each with its basis and its population. The call needs the read grant at the tenant rung.



| | |
|---|---|
| input | [BoardReadInput](/concepts/boardreadinput) |
| result | a card whose body is [BoardAnswer](/concepts/boardanswer) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/BoardAnswer` |
| HTTP route | [`/v1/read/board`](/reference/read/board) |





| field | type | required | note |
|---|---|---|---|
| `board` | `id` | yes |  |
| `period` | [Window](/concepts/window) | no |  |


---
title: "tool si.read.brand_design_system"
description: "the brand, and a version, else the newest: the design system as it stands, with every basis."
section: reference
address: /reference/tools/si-read-brand_design_system
contract: 0476e35e6e275db5
---

# tool si.read.brand_design_system

the brand, and a version, else the newest: the design system as it stands, with every basis.

[figure: Over MCP, si.read.brand_design_system takes BrandDesignSystemInput and returns a card whose body is BrandDesignSystem.]

the design system as it stands, with every basis. The call needs the read grant at the brand rung.



| | |
|---|---|
| input | [BrandDesignSystemInput](/concepts/branddesignsysteminput) |
| result | a card whose body is [BrandDesignSystem](/concepts/branddesignsystem) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/BrandDesignSystem` |
| HTTP route | [`/v1/read/brand_design_system`](/reference/read/brand_design_system) |





| field | type | required | note |
|---|---|---|---|
| `brand` | `id` | yes |  |
| `version` | `count` | no |  |


---
title: "tool si.read.brand_design_system_changes"
description: "the brand and two versions, else the two newest: every value that differs, by path, with the basis on each side, and the counts."
section: reference
address: /reference/tools/si-read-brand_design_system_changes
contract: 0476e35e6e275db5
---

# tool si.read.brand_design_system_changes

the brand and two versions, else the two newest: every value that differs, by path, with the basis on each side, and the counts.

[figure: Over MCP, si.read.brand_design_system_changes takes BrandDesignSystemChangesInput and returns a card whose body is BrandDesignSystemDiff.]

every value that differs, by path, with the basis on each side, and the counts. The call needs the read grant at the brand rung.



| | |
|---|---|
| input | [BrandDesignSystemChangesInput](/concepts/branddesignsystemchangesinput) |
| result | a card whose body is [BrandDesignSystemDiff](/concepts/branddesignsystemdiff) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/BrandDesignSystemDiff` |
| HTTP route | [`/v1/read/brand_design_system_changes`](/reference/read/brand_design_system_changes) |





| field | type | required | note |
|---|---|---|---|
| `brand` | `id` | yes |  |
| `from_version` | `count` | no |  |
| `to_version` | `count` | no |  |


---
title: "tool si.read.browse_view"
description: "a `BrowseViewInput`: one frame of the page as the person sees it, with its size and address, for a dashboard that shows the session live and forwards the person's clicks and words as steps."
section: reference
address: /reference/tools/si-read-browse_view
contract: 0476e35e6e275db5
---

# tool si.read.browse_view

a `BrowseViewInput`: one frame of the page as the person sees it, with its size and address, for a dashboard that shows the session live and forwards the person's clicks and words as steps.

[figure: Over MCP, si.read.browse_view takes BrowseViewInput and returns a card whose body is BrowseView.]

one frame of the page as the person sees it, with its size and address, for a dashboard that shows the session live and forwards the person's clicks and words as steps. The call needs the read grant at the strategy rung.



| | |
|---|---|
| input | [BrowseViewInput](/concepts/browseviewinput) |
| result | a card whose body is [BrowseView](/concepts/browseview) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/BrowseView` |
| HTTP route | [`/v1/read/browse_view`](/reference/read/browse_view) |





| field | type | required | note |
|---|---|---|---|
| `session` | `id` | yes |  |


---
title: "tool si.read.candidates"
description: "Reads the candidates of one brand, narrowed by a buyer profile or by a place: Each candidate arrives with the signals gathered about it, the rung it has reached, and what it still lacks to qualify."
section: reference
address: /reference/tools/si-read-candidates
contract: 0476e35e6e275db5
---

# tool si.read.candidates

Reads the candidates of one brand, narrowed by a buyer profile or by a place: Each candidate arrives with the signals gathered about it, the rung it has reached, and what it still lacks to qualify.

[figure: Over MCP, si.read.candidates takes CandidatesInput and returns a card whose body is [Candidate].]

Each candidate arrives with the signals gathered about it, the rung it has reached, and what it still lacks to qualify. The call needs the read grant at the strategy rung.



| | |
|---|---|
| input | [CandidatesInput](/concepts/candidatesinput) |
| result | a card whose body is [Candidate](/concepts/candidate) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/Candidate` |
| HTTP route | [`/v1/read/candidates`](/reference/read/candidates) |





| field | type | required | note |
|---|---|---|---|
| `brand` | `id` | yes |  |
| `kind_of_buyer` | `id` | no |  |
| `place` | `text` | no |  |
| `candidate` | `id` | no | one candidate |


---
title: "tool si.read.capture_health"
description: "a platform and a window, or nothing: captures by platform in the window against the window before, with a verdict."
section: reference
address: /reference/tools/si-read-capture_health
contract: 0476e35e6e275db5
---

# tool si.read.capture_health

a platform and a window, or nothing: captures by platform in the window against the window before, with a verdict.

[figure: Over MCP, si.read.capture_health takes CaptureHealthInput and returns a card whose body is CaptureHealth.]

captures by platform in the window against the window before, with a verdict. The call needs the read grant at the user rung.



| | |
|---|---|
| input | [CaptureHealthInput](/concepts/capturehealthinput) |
| result | a card whose body is [CaptureHealth](/concepts/capturehealth) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/CaptureHealth` |
| HTTP route | [`/v1/read/capture_health`](/reference/read/capture_health) |





| field | type | required | note |
|---|---|---|---|
| `platform` | `text` | no |  |
| `window` | [Window](/concepts/window) | no |  |


---
title: "tool si.read.capture_rules"
description: "a platform, or nothing: the rules with each platform's readiness."
section: reference
address: /reference/tools/si-read-capture_rules
contract: 0476e35e6e275db5
---

# tool si.read.capture_rules

a platform, or nothing: the rules with each platform's readiness.

[figure: Over MCP, si.read.capture_rules takes CaptureRulesInput and returns a card whose body is [CaptureRule].]

the rules with each platform's readiness. The call needs the read grant at the user rung.



| | |
|---|---|
| input | [CaptureRulesInput](/concepts/capturerulesinput) |
| result | a card whose body is [CaptureRule](/concepts/capturerule) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/CaptureRule` |
| HTTP route | [`/v1/read/capture_rules`](/reference/read/capture_rules) |





| field | type | required | note |
|---|---|---|---|
| `platform` | `text` | no |  |


---
title: "tool si.read.catalogue"
description: "a tenant or a brand: every source and connector with its kinds of reading and action, its state, the identity it needs, its cost, its rights, its coverage and its health."
section: reference
address: /reference/tools/si-read-catalogue
contract: 0476e35e6e275db5
---

# tool si.read.catalogue

a tenant or a brand: every source and connector with its kinds of reading and action, its state, the identity it needs, its cost, its rights, its coverage and its health.

[figure: Over MCP, si.read.catalogue takes CatalogueInput and returns a card whose body is [SourceCatalogueEntry].]

every source and connector with its kinds of reading and action, its state, the identity it needs, its cost, its rights, its coverage and its health. The call needs the read grant at the tenant rung.



| | |
|---|---|
| input | [CatalogueInput](/concepts/catalogueinput) |
| result | a card whose body is [SourceCatalogueEntry](/concepts/sourcecatalogueentry) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/SourceCatalogueEntry` |
| HTTP route | [`/v1/read/catalogue`](/reference/read/catalogue) |





| field | type | required | note |
|---|---|---|---|
| `tenant` | `id` | no |  |
| `brand` | `id` | no |  |
| `filter` | `text` | no |  |


---
title: "tool si.read.chain"
description: "a brand: its roles, its handovers and each handover's count with its instrument."
section: reference
address: /reference/tools/si-read-chain
contract: 0476e35e6e275db5
---

# tool si.read.chain

a brand: its roles, its handovers and each handover's count with its instrument.

[figure: Over MCP, si.read.chain takes MapInput and returns a card whose body is Chain.]

its roles, its handovers and each handover's count with its instrument. The call needs the read grant at the brand rung.



| | |
|---|---|
| input | [MapInput](/concepts/mapinput) |
| result | a card whose body is [Chain](/concepts/chain) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/Chain` |
| HTTP route | [`/v1/read/chain`](/reference/read/chain) |





| field | type | required | note |
|---|---|---|---|
| `brand` | `id` | yes |  |


---
title: "tool si.read.compare"
description: "two brands, a question from the closed list of comparisons: two summaries over one structure, each with its coverage."
section: reference
address: /reference/tools/si-read-compare
contract: 0476e35e6e275db5
---

# tool si.read.compare

two brands, a question from the closed list of comparisons: two summaries over one structure, each with its coverage.

[figure: Over MCP, si.read.compare takes CompareInput and returns a card whose body is Comparison.]

two summaries over one structure, each with its coverage. The call needs the read grant at the brand rung.



| | |
|---|---|
| input | [CompareInput](/concepts/compareinput) |
| result | a card whose body is [Comparison](/concepts/comparison) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/Comparison` |
| HTTP route | [`/v1/read/compare`](/reference/read/compare) |





| field | type | required | note |
|---|---|---|---|
| `first` | `id` | yes |  |
| `second` | `id` | yes |  |
| `question` | [ComparisonQuestion](/concepts/comparisonquestion) | yes |  |


---
title: "tool si.read.connectors"
description: "a tenant or a brand: every kind of reading and of action, by source, with its state, the identity it needs, its cost and its rights."
section: reference
address: /reference/tools/si-read-connectors
contract: 0476e35e6e275db5
---

# tool si.read.connectors

a tenant or a brand: every kind of reading and of action, by source, with its state, the identity it needs, its cost and its rights.

[figure: Over MCP, si.read.connectors takes ConnectorsInput and returns a card whose body is ConnectorOffer.]

every kind of reading and of action, by source, with its state, the identity it needs, its cost and its rights. The call needs the read grant at the tenant rung.



| | |
|---|---|
| input | [ConnectorsInput](/concepts/connectorsinput) |
| result | a card whose body is [ConnectorOffer](/concepts/connectoroffer) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/ConnectorOffer` |
| HTTP route | [`/v1/read/connectors`](/reference/read/connectors) |





| field | type | required | note |
|---|---|---|---|
| `tenant` | `id` | no |  |
| `brand` | `id` | no |  |


---
title: "tool si.read.consent"
description: "the person or tenant, and the use: a fact."
section: reference
address: /reference/tools/si-read-consent
contract: 0476e35e6e275db5
---

# tool si.read.consent

the person or tenant, and the use: a fact.

[figure: Over MCP, si.read.consent takes ConsentInput and returns a card whose body is ConsentAnswer.]

a fact. Or yes or no, with the fact that decides. The call needs the read grant at the tenant rung.



| | |
|---|---|
| input | [ConsentInput](/concepts/consentinput) |
| result | a card whose body is [ConsentAnswer](/concepts/consentanswer) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/ConsentAnswer` |
| HTTP route | [`/v1/read/consent`](/reference/read/consent) |





| field | type | required | note |
|---|---|---|---|
| `subject` | `id` | yes |  |
| `use` | `text` | yes |  |
| `do` | `one of record \| withdraw \| ask` | yes |  |
| `how` | `text` | no |  |
| `evidence` | `[id]` | no |  |


---
title: "tool si.read.coverage"
description: "a cell, or a scope of entities with a window: what has been read, when and how deep, in the three positions."
section: reference
address: /reference/tools/si-read-coverage
contract: 0476e35e6e275db5
---

# tool si.read.coverage

a cell, or a scope of entities with a window: what has been read, when and how deep, in the three positions.

[figure: Over MCP, si.read.coverage takes CoverageInput and returns a card whose body is Coverage.]

what has been read, when and how deep, in the three positions. The call needs the read grant at the brand rung.



| | |
|---|---|
| input | [CoverageInput](/concepts/coverageinput) |
| result | a card whose body is [Coverage](/concepts/coverage) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/Coverage` |
| HTTP route | [`/v1/read/coverage`](/reference/read/coverage) |





| field | type | required | note |
|---|---|---|---|
| `cell` | `id` | no |  |
| `scope` | [Predicate](/concepts/predicate) | no |  |
| `window` | [Window](/concepts/window) | no |  |


---
title: "tool si.read.coverage_by_cell"
description: "a source, or a scope with a window: measured, never measured with the reason, withheld."
section: reference
address: /reference/tools/si-read-coverage_by_cell
contract: 0476e35e6e275db5
---

# tool si.read.coverage_by_cell

a source, or a scope with a window: measured, never measured with the reason, withheld.

[figure: Over MCP, si.read.coverage_by_cell takes CoverageByCellInput and returns a card whose body is Coverage.]

measured, never measured with the reason, withheld. The call needs the read grant at the brand rung.



| | |
|---|---|
| input | [CoverageByCellInput](/concepts/coveragebycellinput) |
| result | a card whose body is [Coverage](/concepts/coverage) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/Coverage` |
| HTTP route | [`/v1/read/coverage_by_cell`](/reference/read/coverage_by_cell) |





| field | type | required | note |
|---|---|---|---|
| `source` | `id` | no |  |
| `scope` | [Predicate](/concepts/predicate) | no |  |
| `window` | [Window](/concepts/window) | no |  |


---
title: "tool si.read.document"
description: "the document, the version, the caller: the version, with when it was built and what it was built from."
section: reference
address: /reference/tools/si-read-document
contract: 0476e35e6e275db5
---

# tool si.read.document

the document, the version, the caller: the version, with when it was built and what it was built from.

[figure: Over MCP, si.read.document takes DocumentInput and returns a card whose body is Build.]

the version, with when it was built and what it was built from. The call needs the read grant at the brand rung.



| | |
|---|---|
| input | [DocumentInput](/concepts/documentinput) |
| result | a card whose body is [Build](/concepts/build) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/Build` |
| HTTP route | [`/v1/read/document`](/reference/read/document) |





| field | type | required | note |
|---|---|---|---|
| `document` | `id` | yes |  |
| `version` | `count` | no |  |


---
title: "tool si.read.document_changes"
description: "two versions: every number that moved with its unit, every figure replaced."
section: reference
address: /reference/tools/si-read-document_changes
contract: 0476e35e6e275db5
---

# tool si.read.document_changes

two versions: every number that moved with its unit, every figure replaced.

[figure: Over MCP, si.read.document_changes takes DocumentChangesInput and returns a card whose body is WhatChanged.]

every number that moved with its unit, every figure replaced. The call needs the read grant at the brand rung.



| | |
|---|---|
| input | [DocumentChangesInput](/concepts/documentchangesinput) |
| result | a card whose body is [WhatChanged](/concepts/whatchanged) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/WhatChanged` |
| HTTP route | [`/v1/read/document_changes`](/reference/read/document_changes) |





| field | type | required | note |
|---|---|---|---|
| `document` | `id` | yes |  |
| `first` | `count` | yes |  |
| `second` | `count` | yes |  |


---
title: "tool si.read.effect"
description: "a move, the window: the effect with its interval, or withheld with what would settle it."
section: reference
address: /reference/tools/si-read-effect
contract: 0476e35e6e275db5
---

# tool si.read.effect

a move, the window: the effect with its interval, or withheld with what would settle it.

[figure: Over MCP, si.read.effect takes EffectInput and returns a card whose body is Effect.]

the effect with its interval, or withheld with what would settle it. The call needs the read grant at the strategy rung.



| | |
|---|---|
| input | [EffectInput](/concepts/effectinput) |
| result | a card whose body is [Effect](/concepts/effect) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/Effect` |
| HTTP route | [`/v1/read/effect`](/reference/read/effect) |





| field | type | required | note |
|---|---|---|---|
| `move` | `id` | yes |  |
| `window` | [Window](/concepts/window) | no |  |


---
title: "tool si.read.entity"
description: "an entity, and the two dates: every identifier it ever had, every account, everything it published, every thread, community and gathering, and every connection, across platforms and sources."
section: reference
address: /reference/tools/si-read-entity
contract: 0476e35e6e275db5
---

# tool si.read.entity

an entity, and the two dates: every identifier it ever had, every account, everything it published, every thread, community and gathering, and every connection, across platforms and sources.

[figure: Over MCP, si.read.entity takes EntityInput and returns a card whose body is EntitySurface.]

every identifier it ever had, every account, everything it published, every thread, community and gathering, and every connection, across platforms and sources. The call needs the read grant at the strategy rung.



| | |
|---|---|
| input | [EntityInput](/concepts/entityinput) |
| result | a card whose body is [EntitySurface](/concepts/entitysurface) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/EntitySurface` |
| HTTP route | [`/v1/read/entity`](/reference/read/entity) |





| field | type | required | note |
|---|---|---|---|
| `entity` | `id` | yes |  |


---
title: "tool si.read.estimate"
description: "an estimator, the case: the estimate with its interval, its evidence and its familiarity, or withheld."
section: reference
address: /reference/tools/si-read-estimate
contract: 0476e35e6e275db5
---

# tool si.read.estimate

an estimator, the case: the estimate with its interval, its evidence and its familiarity, or withheld.

[figure: Over MCP, si.read.estimate takes EstimateInput and returns a card whose body is Estimate.]

the estimate with its interval, its evidence and its familiarity, or withheld. The call needs the read grant at the strategy rung.



| | |
|---|---|
| input | [EstimateInput](/concepts/estimateinput) |
| result | a card whose body is [Estimate](/concepts/estimate) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/Estimate` |
| HTTP route | [`/v1/read/estimate`](/reference/read/estimate) |





| field | type | required | note |
|---|---|---|---|
| `model` | [Model](/concepts/model) | yes |  |
| `case` | [UnitRef](/concepts/unitref) | yes |  |


---
title: "tool si.read.explain_catch"
description: "the match: the conditions that admitted it, the words each matched, the observation, and the source."
section: reference
address: /reference/tools/si-read-explain_catch
contract: 0476e35e6e275db5
---

# tool si.read.explain_catch

the match: the conditions that admitted it, the words each matched, the observation, and the source.

[figure: Over MCP, si.read.explain_catch takes UnitRef and returns a card whose body is Catch.]

the conditions that admitted it, the words each matched, the observation, and the source. The call needs the read grant at the strategy rung.



| | |
|---|---|
| input | [UnitRef](/concepts/unitref) |
| result | a card whose body is [Catch](/concepts/catch) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/Catch` |
| HTTP route | [`/v1/read/explain_catch`](/reference/read/explain_catch) |





| field | type | required | note |
|---|---|---|---|
| `id` | `id` | yes |  |
| `kind` | [Kind](/concepts/kind) | yes |  |


---
title: "tool si.read.failed_calls"
description: "a tenant: every signed call that did not land, with why, and a way to send it again."
section: reference
address: /reference/tools/si-read-failed_calls
contract: 0476e35e6e275db5
---

# tool si.read.failed_calls

a tenant: every signed call that did not land, with why, and a way to send it again.

[figure: Over MCP, si.read.failed_calls takes ConnectorsInput and returns a card whose body is [FailedCall].]

every signed call that did not land, with why, and a way to send it again. The call needs the read grant at the tenant rung.



| | |
|---|---|
| input | [ConnectorsInput](/concepts/connectorsinput) |
| result | a card whose body is [FailedCall](/concepts/failedcall) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/FailedCall` |
| HTTP route | [`/v1/read/failed_calls`](/reference/read/failed_calls) |





| field | type | required | note |
|---|---|---|---|
| `tenant` | `id` | no |  |
| `brand` | `id` | no |  |


---
title: "tool si.read.fit_frame"
description: "Reads the frame of one fit search: The answer gives the markets ranked, the offering sculpted for each buyer profile, the tactics proposed to test the fit, the verdict for each market, and the set of options that compares them."
section: reference
address: /reference/tools/si-read-fit_frame
contract: 0476e35e6e275db5
---

# tool si.read.fit_frame

Reads the frame of one fit search: The answer gives the markets ranked, the offering sculpted for each buyer profile, the tactics proposed to test the fit, the verdict for each market, and the set of options that compares them.

[figure: Over MCP, si.read.fit_frame takes FitFrameInput and returns a card whose body is FitSearchFrame.]

The answer gives the markets ranked, the offering sculpted for each buyer profile, the tactics proposed to test the fit, the verdict for each market, and the set of options that compares them. The call needs the read grant at the brand rung.



| | |
|---|---|
| input | [FitFrameInput](/concepts/fitframeinput) |
| result | a card whose body is [FitSearchFrame](/concepts/fitsearchframe) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/FitSearchFrame` |
| HTTP route | [`/v1/read/fit_frame`](/reference/read/fit_frame) |





| field | type | required | note |
|---|---|---|---|
| `search` | `id` | yes |  |


---
title: "tool si.read.fit_plays"
description: "Reads the tactics that fit one phase of the search, for a vertical or a kind of offering: The answer gives the tactics in the order to run them."
section: reference
address: /reference/tools/si-read-fit_plays
contract: 0476e35e6e275db5
---

# tool si.read.fit_plays

Reads the tactics that fit one phase of the search, for a vertical or a kind of offering: The answer gives the tactics in the order to run them.

[figure: Over MCP, si.read.fit_plays takes FitPlaysInput and returns a card whose body is [Tactic].]

The answer gives the tactics in the order to run them. The call needs the read grant at the tenant rung.



| | |
|---|---|
| input | [FitPlaysInput](/concepts/fitplaysinput) |
| result | a card whose body is [Tactic](/concepts/tactic) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/Tactic` |
| HTTP route | [`/v1/read/fit_plays`](/reference/read/fit_plays) |





| field | type | required | note |
|---|---|---|---|
| `phase` | `one of find the market \| sculpt the offering \| test the fit \| build a beachhead \| engineer demand \| find demand \| grow in a market \| hedge` | yes |  |
| `vertical` | `id` | no |  |
| `kind_of_offering` | [KindOfOffering](/concepts/kindofoffering) | no |  |


---
title: "tool si.read.forecasts"
description: "a play or a tactic, across brands: every forecast with its effect, how well the band held, and the proper score by play, tactic, kind of buyer, framing, actor and content."
section: reference
address: /reference/tools/si-read-forecasts
contract: 0476e35e6e275db5
---

# tool si.read.forecasts

a play or a tactic, across brands: every forecast with its effect, how well the band held, and the proper score by play, tactic, kind of buyer, framing, actor and content.

[figure: Over MCP, si.read.forecasts takes ForecastsInput and returns a card whose body is ForecastsAnswer.]

every forecast with its effect, how well the band held, and the proper score by play, tactic, kind of buyer, framing, actor and content. The call needs the read grant at the brand rung.



| | |
|---|---|
| input | [ForecastsInput](/concepts/forecastsinput) |
| result | a card whose body is [ForecastsAnswer](/concepts/forecastsanswer) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/ForecastsAnswer` |
| HTTP route | [`/v1/read/forecasts`](/reference/read/forecasts) |





| field | type | required | note |
|---|---|---|---|
| `play` | `id` | no |  |
| `tactic` | [Tactic](/concepts/tactic) | no |  |


---
title: "tool si.read.grounding_priors"
description: "a platform, or nothing (`GroundingPriorsInput`): how often a person supported each kind of suggestion at each breadth, one row per kind, platform and breadth (`GroundingPriors`)."
section: reference
address: /reference/tools/si-read-grounding_priors
contract: 0476e35e6e275db5
---

# tool si.read.grounding_priors

a platform, or nothing (`GroundingPriorsInput`): how often a person supported each kind of suggestion at each breadth, one row per kind, platform and breadth (`GroundingPriors`).

[figure: Over MCP, si.read.grounding_priors takes GroundingPriorsInput and returns a card whose body is GroundingPriors.]

how often a person supported each kind of suggestion at each breadth, one row per kind, platform and breadth (`GroundingPriors`). The call needs the read grant at the user rung.



| | |
|---|---|
| input | [GroundingPriorsInput](/concepts/groundingpriorsinput) |
| result | a card whose body is [GroundingPriors](/concepts/groundingpriors) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/GroundingPriors` |
| HTTP route | [`/v1/read/grounding_priors`](/reference/read/grounding_priors) |





| field | type | required | note |
|---|---|---|---|
| `platform` | `text` | no |  |


---
title: "tool si.read.groundings"
description: "one capture's, one entity's, or every grounding in a place: each grounding with its hypotheses."
section: reference
address: /reference/tools/si-read-groundings
contract: 0476e35e6e275db5
---

# tool si.read.groundings

one capture's, one entity's, or every grounding in a place: each grounding with its hypotheses.

[figure: Over MCP, si.read.groundings takes GroundingsInput and returns a card whose body is [GroundingAnswer].]

each grounding with its hypotheses. The call needs the read grant at the user rung.



| | |
|---|---|
| input | [GroundingsInput](/concepts/groundingsinput) |
| result | a card whose body is [GroundingAnswer](/concepts/groundinganswer) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/GroundingAnswer` |
| HTTP route | [`/v1/read/groundings`](/reference/read/groundings) |





| field | type | required | note |
|---|---|---|---|
| `capture` | `hash` | no |  |
| `entity` | `id` | no |  |
| `place` | `one of staged \| grounding \| waiting for a person \| committed \| discarded \| all` | no |  |


---
title: "tool si.read.instruction_set"
description: "nothing: the set at its current version, assembled."
section: reference
address: /reference/tools/si-read-instruction_set
contract: 0476e35e6e275db5
---

# tool si.read.instruction_set

nothing: the set at its current version, assembled.

[figure: Over MCP, si.read.instruction_set takes Nothing and returns a card whose body is InstructionSet.]

the set at its current version, assembled. The call needs the read grant at the user rung.



| | |
|---|---|
| input | [Nothing](/concepts/nothing) |
| result | a card whose body is [InstructionSet](/concepts/instructionset) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/InstructionSet` |
| HTTP route | [`/v1/read/instruction_set`](/reference/read/instruction_set) |


---
title: "tool si.read.intelligence"
description: "a subject and a kind of intelligence: the kind's facts about the subject with their basis, their coverage and their date."
section: reference
address: /reference/tools/si-read-intelligence
contract: 0476e35e6e275db5
---

# tool si.read.intelligence

a subject and a kind of intelligence: the kind's facts about the subject with their basis, their coverage and their date.

[figure: Over MCP, si.read.intelligence takes IntelligenceInput and returns a card whose body is IntelligenceAnswer.]

the kind's facts about the subject with their basis, their coverage and their date. The call needs the read grant at the strategy rung.



| | |
|---|---|
| input | [IntelligenceInput](/concepts/intelligenceinput) |
| result | a card whose body is [IntelligenceAnswer](/concepts/intelligenceanswer) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/IntelligenceAnswer` |
| HTTP route | [`/v1/read/intelligence`](/reference/read/intelligence) |





| field | type | required | note |
|---|---|---|---|
| `subject` | `id` | yes |  |
| `kind` | `text` | yes | one of the register's kinds |


---
title: "tool si.read.invitations"
description: "nothing: the invitations with their states."
section: reference
address: /reference/tools/si-read-invitations
contract: 0476e35e6e275db5
---

# tool si.read.invitations

nothing: the invitations with their states.

[figure: Over MCP, si.read.invitations takes Nothing and returns a card whose body is [Invitation].]

the invitations with their states. The call needs the admin grant at the tenant rung.



| | |
|---|---|
| input | [Nothing](/concepts/nothing) |
| result | a card whose body is [Invitation](/concepts/invitation) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/Invitation` |
| HTTP route | [`/v1/read/invitations`](/reference/read/invitations) |


---
title: "tool si.read.invoices"
description: "a period, or nothing: the invoices with their states."
section: reference
address: /reference/tools/si-read-invoices
contract: 0476e35e6e275db5
---

# tool si.read.invoices

a period, or nothing: the invoices with their states.

[figure: Over MCP, si.read.invoices takes InvoicesInput and returns a card whose body is [Invoice].]

the invoices with their states. The call needs the read grant at the tenant rung.



| | |
|---|---|
| input | [InvoicesInput](/concepts/invoicesinput) |
| result | a card whose body is [Invoice](/concepts/invoice) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/Invoice` |
| HTTP route | [`/v1/read/invoices`](/reference/read/invoices) |





| field | type | required | note |
|---|---|---|---|
| `period` | [Window](/concepts/window) | no |  |


---
title: "tool si.read.leads"
description: "Reads the leads of one brand, narrowed by a place, a condition or a user: The answer gives the leads, or the package that holds them."
section: reference
address: /reference/tools/si-read-leads
contract: 0476e35e6e275db5
---

# tool si.read.leads

Reads the leads of one brand, narrowed by a place, a condition or a user: The answer gives the leads, or the package that holds them.

[figure: Over MCP, si.read.leads takes LeadsInput and returns a card whose body is [Lead].]

The answer gives the leads, or the package that holds them. The call needs the read grant at the strategy rung.



| | |
|---|---|
| input | [LeadsInput](/concepts/leadsinput) |
| result | a card whose body is [Lead](/concepts/lead) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/Lead` |
| HTTP route | [`/v1/read/leads`](/reference/read/leads) |





| field | type | required | note |
|---|---|---|---|
| `brand` | `id` | yes |  |
| `place` | `text` | no |  |
| `condition` | [LeadCondition](/concepts/leadcondition) | no |  |
| `person` | `id` | no |  |
| `lead` | `id` | no | one lead, as its package |


---
title: "tool si.read.ledger"
description: "a strategy, the window: every move, action, forecast, effect and impact in order, with the budget spent by kind."
section: reference
address: /reference/tools/si-read-ledger
contract: 0476e35e6e275db5
---

# tool si.read.ledger

a strategy, the window: every move, action, forecast, effect and impact in order, with the budget spent by kind.

[figure: Over MCP, si.read.ledger takes LedgerInput and returns a card whose body is Ledger.]

every move, action, forecast, effect and impact in order, with the budget spent by kind. The call needs the read grant at the strategy rung.



| | |
|---|---|
| input | [LedgerInput](/concepts/ledgerinput) |
| result | a card whose body is [Ledger](/concepts/ledger) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/Ledger` |
| HTTP route | [`/v1/read/ledger`](/reference/read/ledger) |





| field | type | required | note |
|---|---|---|---|
| `strategy` | `id` | yes |  |
| `window` | [Window](/concepts/window) | yes |  |


---
title: "tool si.read.lineage"
description: "an artefact: its whole history and footprint, marking unavailable what a store cannot answer."
section: reference
address: /reference/tools/si-read-lineage
contract: 0476e35e6e275db5
---

# tool si.read.lineage

an artefact: its whole history and footprint, marking unavailable what a store cannot answer.

[figure: Over MCP, si.read.lineage takes LineageInput and returns a card whose body is Lineage.]

its whole history and footprint, marking unavailable what a store cannot answer. The call needs the read grant at the strategy rung.



| | |
|---|---|
| input | [LineageInput](/concepts/lineageinput) |
| result | a card whose body is [Lineage](/concepts/lineage) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/Lineage` |
| HTTP route | [`/v1/read/lineage`](/reference/read/lineage) |





| field | type | required | note |
|---|---|---|---|
| `artefact_hash` | `hash` | no |  |
| `unit` | `id` | no |  |


---
title: "tool si.read.lookup"
description: "a key: a namespace with a value, or a name with a place, and with a name a breadth."
section: reference
address: /reference/tools/si-read-lookup
contract: 0476e35e6e275db5
---

# tool si.read.lookup

a key: a namespace with a value, or a name with a place, and with a name a breadth.

[figure: Over MCP, si.read.lookup takes LookupInput and returns a card whose body is LookupAnswer.]

the entity, or the possible matches, or nothing; with a breadth, the record's candidates by the one candidate search. The call needs the read grant at the strategy rung.



| | |
|---|---|
| input | [LookupInput](/concepts/lookupinput) |
| result | a card whose body is [LookupAnswer](/concepts/lookupanswer) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/LookupAnswer` |
| HTTP route | [`/v1/read/lookup`](/reference/read/lookup) |





| field | type | required | note |
|---|---|---|---|
| `namespace` | `text` | no |  |
| `value` | `text` | no |  |
| `name` | `text` | no |  |
| `place` | `text` | no |  |
| `kind` | [KindOfEntity](/concepts/kindofentity) | no |  |
| `breadth` | `one of exact \| similar \| related \| broad` | no | with a name: the one candidate search of the record at that breadth, by exact keys, names and meaning, in place of the substring match |


---
title: "tool si.read.map"
description: "a brand, and the two dates: the map."
section: reference
address: /reference/tools/si-read-map
contract: 0476e35e6e275db5
---

# tool si.read.map

a brand, and the two dates: the map.

[figure: Over MCP, si.read.map takes MapInput and returns a card whose body is Map.]

the map. The call needs the read grant at the brand rung.



| | |
|---|---|
| input | [MapInput](/concepts/mapinput) |
| result | a card whose body is [Map](/concepts/map) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/Map` |
| HTTP route | [`/v1/read/map`](/reference/read/map) |





| field | type | required | note |
|---|---|---|---|
| `brand` | `id` | yes |  |


---
title: "tool si.read.market"
description: "a brand, a segment, the window: the four stages, each with its count, value, basis and coverage, and the silent remainder."
section: reference
address: /reference/tools/si-read-market
contract: 0476e35e6e275db5
---

# tool si.read.market

a brand, a segment, the window: the four stages, each with its count, value, basis and coverage, and the silent remainder.

[figure: Over MCP, si.read.market takes MarketInput and returns a card whose body is Market.]

the four stages, each with its count, value, basis and coverage, and the silent remainder. The call needs the read grant at the brand rung.



| | |
|---|---|
| input | [MarketInput](/concepts/marketinput) |
| result | a card whose body is [Market](/concepts/market) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/Market` |
| HTTP route | [`/v1/read/market`](/reference/read/market) |





| field | type | required | note |
|---|---|---|---|
| `brand` | `id` | yes |  |
| `segment` | `id` | yes |  |
| `window` | [Window](/concepts/window) | yes |  |


---
title: "tool si.read.market_twin"
description: "Reads one market twin, and the date to read it as of: The answer gives the twin: the model family and template it was instanced from, the participants placed on the chain, the level of every stock as of the date, the simulations run on it in order, and the strategy whose armed plays are its interventions."
section: reference
address: /reference/tools/si-read-market_twin
contract: 0476e35e6e275db5
---

# tool si.read.market_twin

Reads one market twin, and the date to read it as of: The answer gives the twin: the model family and template it was instanced from, the participants placed on the chain, the level of every stock as of the date, the simulations run on it in order, and the strategy whose armed plays are its interventions.

[figure: Over MCP, si.read.market_twin takes MarketTwinInput and returns a card whose body is MarketTwin.]

The answer gives the twin: the model family and template it was instanced from, the participants placed on the chain, the level of every stock as of the date, the simulations run on it in order, and the strategy whose armed plays are its interventions. The call needs the read grant at the brand rung.



| | |
|---|---|
| input | [MarketTwinInput](/concepts/markettwininput) |
| result | a card whose body is [MarketTwin](/concepts/markettwin) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/MarketTwin` |
| HTTP route | [`/v1/read/market_twin`](/reference/read/market_twin) |





| field | type | required | note |
|---|---|---|---|
| `twin` | `id` | yes |  |
| `as_of` | `time` | no |  |


---
title: "tool si.read.methods"
description: "a question, or nothing: the methods that answer it, or every method, each with its readiness."
section: reference
address: /reference/tools/si-read-methods
contract: 0476e35e6e275db5
---

# tool si.read.methods

a question, or nothing: the methods that answer it, or every method, each with its readiness.

[figure: Over MCP, si.read.methods takes MethodsInput and returns a card whose body is [Method].]

the methods that answer it, or every method, each with its readiness. The call needs the read grant at the user rung.



| | |
|---|---|
| input | [MethodsInput](/concepts/methodsinput) |
| result | a card whose body is [Method](/concepts/method) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/Method` |
| HTTP route | [`/v1/read/methods`](/reference/read/methods) |





| field | type | required | note |
|---|---|---|---|
| `question` | `text` | no |  |


---
title: "tool si.read.model_families"
description: "Reads the model families that fit a vertical or a representation: Each family arrives with what it represents, the substrate it is written over, its solver and its check."
section: reference
address: /reference/tools/si-read-model_families
contract: 0476e35e6e275db5
---

# tool si.read.model_families

Reads the model families that fit a vertical or a representation: Each family arrives with what it represents, the substrate it is written over, its solver and its check.

[figure: Over MCP, si.read.model_families takes ModelFamiliesInput and returns a card whose body is [ModelFamily].]

Each family arrives with what it represents, the substrate it is written over, its solver and its check. The call needs the read grant at the tenant rung.



| | |
|---|---|
| input | [ModelFamiliesInput](/concepts/modelfamiliesinput) |
| result | a card whose body is [ModelFamily](/concepts/modelfamily) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/ModelFamily` |
| HTTP route | [`/v1/read/model_families`](/reference/read/model_families) |





| field | type | required | note |
|---|---|---|---|
| `vertical` | `id` | no |  |
| `representation` | `one of stocks and flows \| a graph of participants and handovers \| a hypergraph of co-presence \| agents with behaviours \| a game of roles` | no |  |


---
title: "tool si.read.monitor_strength"
description: "the monitor and a window: the four numbers, each with its population."
section: reference
address: /reference/tools/si-read-monitor_strength
contract: 0476e35e6e275db5
---

# tool si.read.monitor_strength

the monitor and a window: the four numbers, each with its population.

[figure: Over MCP, si.read.monitor_strength takes MonitorStrengthInput and returns a card whose body is SignalStrength.]

the four numbers, each with its population. The call needs the read grant at the strategy rung.



| | |
|---|---|
| input | [MonitorStrengthInput](/concepts/monitorstrengthinput) |
| result | a card whose body is [SignalStrength](/concepts/signalstrength) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/SignalStrength` |
| HTTP route | [`/v1/read/monitor_strength`](/reference/read/monitor_strength) |





| field | type | required | note |
|---|---|---|---|
| `monitor` | `id` | yes |  |
| `window` | [Window](/concepts/window) | yes |  |


---
title: "tool si.read.page_changes"
description: "a `PageChangesInput`: `PageChange` rows for the site or the watch in the window."
section: reference
address: /reference/tools/si-read-page_changes
contract: 0476e35e6e275db5
---

# tool si.read.page_changes

a `PageChangesInput`: `PageChange` rows for the site or the watch in the window.

[figure: Over MCP, si.read.page_changes takes PageChangesInput and returns a card whose body is [PageChange].]

`PageChange` rows for the site or the watch in the window. The call needs the read grant at the brand rung.



| | |
|---|---|
| input | [PageChangesInput](/concepts/pagechangesinput) |
| result | a card whose body is [PageChange](/concepts/pagechange) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/PageChange` |
| HTTP route | [`/v1/read/page_changes`](/reference/read/page_changes) |





| field | type | required | note |
|---|---|---|---|
| `site` | `id` | no |  |
| `watch` | `id` | no |  |
| `window` | [Window](/concepts/window) | yes |  |


---
title: "tool si.read.parameter"
description: "its name: its value, with its dimension and version."
section: reference
address: /reference/tools/si-read-parameter
contract: 0476e35e6e275db5
---

# tool si.read.parameter

its name: its value, with its dimension and version.

[figure: Over MCP, si.read.parameter takes ParameterInput and returns a card whose body is Parameter.]

its value, with its dimension and version. The call needs the read grant at the tenant rung.



| | |
|---|---|
| input | [ParameterInput](/concepts/parameterinput) |
| result | a card whose body is [Parameter](/concepts/parameter) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/Parameter` |
| HTTP route | [`/v1/read/parameter`](/reference/read/parameter) |





| field | type | required | note |
|---|---|---|---|
| `name` | `text` | yes |  |
| `scope` | [Scope](/concepts/scope) | no |  |


---
title: "tool si.read.plan_report"
description: "a strategy and a window (`PlanReportInput`): each play completed, partial or missing, and the items done off plan."
section: reference
address: /reference/tools/si-read-plan_report
contract: 0476e35e6e275db5
---

# tool si.read.plan_report

a strategy and a window (`PlanReportInput`): each play completed, partial or missing, and the items done off plan.

[figure: Over MCP, si.read.plan_report takes PlanReportInput and returns a card whose body is PlanReport.]

each play completed, partial or missing, and the items done off plan. The call needs the read grant at the strategy rung.



| | |
|---|---|
| input | [PlanReportInput](/concepts/planreportinput) |
| result | a card whose body is [PlanReport](/concepts/planreport) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/PlanReport` |
| HTTP route | [`/v1/read/plan_report`](/reference/read/plan_report) |





| field | type | required | note |
|---|---|---|---|
| `strategy` | `id` | yes |  |
| `window` | [Window](/concepts/window) | no |  |


---
title: "tool si.read.policy_replay"
description: "a policy row and its version, a strategy and a window (`PolicyReplayInput`): what the policy would have chosen at every logged decision against what was chosen, and the effects that followed (`PolicyReplay`)."
section: reference
address: /reference/tools/si-read-policy_replay
contract: 0476e35e6e275db5
---

# tool si.read.policy_replay

a policy row and its version, a strategy and a window (`PolicyReplayInput`): what the policy would have chosen at every logged decision against what was chosen, and the effects that followed (`PolicyReplay`).

[figure: Over MCP, si.read.policy_replay takes PolicyReplayInput and returns a card whose body is PolicyReplay.]

what the policy would have chosen at every logged decision against what was chosen, and the effects that followed (`PolicyReplay`). The call needs the read grant at the strategy rung.



| | |
|---|---|
| input | [PolicyReplayInput](/concepts/policyreplayinput) |
| result | a card whose body is [PolicyReplay](/concepts/policyreplay) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/PolicyReplay` |
| HTTP route | [`/v1/read/policy_replay`](/reference/read/policy_replay) |





| field | type | required | note |
|---|---|---|---|
| `policy` | [Policy](/concepts/policy) | yes |  |
| `strategy` | `id` | yes |  |
| `window` | [Window](/concepts/window) | no |  |


---
title: "tool si.read.posture"
description: "a community, the window: open, conditional, closed or unknown, with the two removal rates and the archetype."
section: reference
address: /reference/tools/si-read-posture
contract: 0476e35e6e275db5
---

# tool si.read.posture

a community, the window: open, conditional, closed or unknown, with the two removal rates and the archetype.

[figure: Over MCP, si.read.posture takes PostureInput and returns a card whose body is CommunityPosture.]

open, conditional, closed or unknown, with the two removal rates and the archetype. The call needs the read grant at the brand rung.



| | |
|---|---|
| input | [PostureInput](/concepts/postureinput) |
| result | a card whose body is [CommunityPosture](/concepts/communityposture) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/CommunityPosture` |
| HTTP route | [`/v1/read/posture`](/reference/read/posture) |





| field | type | required | note |
|---|---|---|---|
| `community` | `id` | yes |  |
| `window` | [Window](/concepts/window) | no |  |


---
title: "tool si.read.predicate_language"
description: "the register's name: its rows with the hash."
section: reference
address: /reference/tools/si-read-predicate_language
contract: 0476e35e6e275db5
---

# tool si.read.predicate_language

the register's name: its rows with the hash.

[figure: Over MCP, si.read.predicate_language takes Nothing and returns a card whose body is PredicateLanguage.]

its rows with the hash. The call needs the read grant at the tenant rung.



| | |
|---|---|
| input | [Nothing](/concepts/nothing) |
| result | a card whose body is [PredicateLanguage](/concepts/predicatelanguage) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/PredicateLanguage` |
| HTTP route | [`/v1/read/predicate_language`](/reference/read/predicate_language) |


---
title: "tool si.read.propensity"
description: "a lead, a move or a play, and which faces, actors or content or both (`PropensityInput`): every eligible actor and every fitting content with the chance, its interval, its basis and the policy's odds, and the one the policy would choose (`PropensityAnswer`)."
section: reference
address: /reference/tools/si-read-propensity
contract: 0476e35e6e275db5
---

# tool si.read.propensity

a lead, a move or a play, and which faces, actors or content or both (`PropensityInput`): every eligible actor and every fitting content with the chance, its interval, its basis and the policy's odds, and the one the policy would choose (`PropensityAnswer`).

[figure: Over MCP, si.read.propensity takes PropensityInput and returns a card whose body is PropensityAnswer.]

every eligible actor and every fitting content with the chance, its interval, its basis and the policy's odds, and the one the policy would choose (`PropensityAnswer`). The call needs the read grant at the strategy rung.



| | |
|---|---|
| input | [PropensityInput](/concepts/propensityinput) |
| result | a card whose body is [PropensityAnswer](/concepts/propensityanswer) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/PropensityAnswer` |
| HTTP route | [`/v1/read/propensity`](/reference/read/propensity) |





| field | type | required | note |
|---|---|---|---|
| `lead` | `id` | yes |  |
| `move` | `id` | no |  |
| `play` | `id` | no |  |
| `faces` | `[one of actor \| content]` | yes |  |


---
title: "tool si.read.proxy"
description: "the proxy and its version, the two dates, and a place: its members as a population, with the raw count, the estimate corrected by the recall and the undercount's interval, its calibration by segment, its coverage by channel, and its co-membership with other proxies; for an aggregate-only proxy the counts alone and…"
section: reference
address: /reference/tools/si-read-proxy
contract: 0476e35e6e275db5
---

# tool si.read.proxy

the proxy and its version, the two dates, and a place: its members as a population, with the raw count, the estimate corrected by the recall and the undercount's interval, its calibration by segment, its coverage by channel, and its co-membership with other proxies; for an aggregate-only proxy the counts alone and…

[figure: Over MCP, si.read.proxy takes ProxyReadInput and returns a card whose body is ProxyReading.]

its members as a population, with the raw count, the estimate corrected by the recall and the undercount's interval, its calibration by segment, its coverage by channel, and its co-membership with other proxies; for an aggregate-only proxy the counts alone and never a member. The call needs the read grant at the strategy rung.



| | |
|---|---|
| input | [ProxyReadInput](/concepts/proxyreadinput) |
| result | a card whose body is [ProxyReading](/concepts/proxyreading) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/ProxyReading` |
| HTTP route | [`/v1/read/proxy`](/reference/read/proxy) |





| field | type | required | note |
|---|---|---|---|
| `proxy` | `id` | yes |  |
| `window` | [Window](/concepts/window) | no |  |


---
title: "tool si.read.receipts"
description: "the kind, export or erasure: the receipts."
section: reference
address: /reference/tools/si-read-receipts
contract: 0476e35e6e275db5
---

# tool si.read.receipts

the kind, export or erasure: the receipts.

[figure: Over MCP, si.read.receipts takes ReceiptsInput and returns a card whose body is Receipts.]

the receipts. The call needs the admin grant at the tenant rung.



| | |
|---|---|
| input | [ReceiptsInput](/concepts/receiptsinput) |
| result | a card whose body is [Receipts](/concepts/receipts) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/Receipts` |
| HTTP route | [`/v1/read/receipts`](/reference/read/receipts) |





| field | type | required | note |
|---|---|---|---|
| `kind` | `one of export \| erasure` | yes |  |


---
title: "tool si.read.register"
description: "its name, and a version or *current*: its rows, and the hash."
section: reference
address: /reference/tools/si-read-register
contract: 0476e35e6e275db5
---

# tool si.read.register

its name, and a version or *current*: its rows, and the hash.

[figure: Over MCP, si.read.register takes RegisterInput and returns a card whose body is RegisterAnswer.]

its rows, and the hash. The call needs the read grant at the tenant rung.



| | |
|---|---|
| input | [RegisterInput](/concepts/registerinput) |
| result | a card whose body is [RegisterAnswer](/concepts/registeranswer) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/RegisterAnswer` |
| HTTP route | [`/v1/read/register`](/reference/read/register) |





| field | type | required | note |
|---|---|---|---|
| `register` | `text` | yes |  |
| `name` | `text` | no | is this name registered |


---
title: "tool si.read.registered"
description: "a register and a name: the row, or nothing."
section: reference
address: /reference/tools/si-read-registered
contract: 0476e35e6e275db5
---

# tool si.read.registered

a register and a name: the row, or nothing.

[figure: Over MCP, si.read.registered takes RegisterInput and returns a card whose body is RegisterAnswer.]

the row, or nothing. The call needs the read grant at the tenant rung.



| | |
|---|---|
| input | [RegisterInput](/concepts/registerinput) |
| result | a card whose body is [RegisterAnswer](/concepts/registeranswer) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/RegisterAnswer` |
| HTTP route | [`/v1/read/registered`](/reference/read/registered) |





| field | type | required | note |
|---|---|---|---|
| `register` | `text` | yes |  |
| `name` | `text` | no | is this name registered |


---
title: "tool si.read.roles"
description: "nothing, or one role: the register of roles: each role's side, what it does, what it hands on, which connection holds it, and whether its holder can be a lead."
section: reference
address: /reference/tools/si-read-roles
contract: 0476e35e6e275db5
---

# tool si.read.roles

nothing, or one role: the register of roles: each role's side, what it does, what it hands on, which connection holds it, and whether its holder can be a lead.

[figure: Over MCP, si.read.roles takes RolesInput and returns a card whose body is [RoleAroundADecision].]

the register of roles: each role's side, what it does, what it hands on, which connection holds it, and whether its holder can be a lead. The call needs the read grant at the brand rung.



| | |
|---|---|
| input | [RolesInput](/concepts/rolesinput) |
| result | a card whose body is [RoleAroundADecision](/concepts/rolearoundadecision) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/RoleAroundADecision` |
| HTTP route | [`/v1/read/roles`](/reference/read/roles) |





| field | type | required | note |
|---|---|---|---|
| `role` | `text` | no |  |


---
title: "tool si.read.scrape_runs"
description: "a `ScrapeRunsInput`: `ScrapeRun` rows with pages, rows, bytes, cost and time."
section: reference
address: /reference/tools/si-read-scrape_runs
contract: 0476e35e6e275db5
---

# tool si.read.scrape_runs

a `ScrapeRunsInput`: `ScrapeRun` rows with pages, rows, bytes, cost and time.

[figure: Over MCP, si.read.scrape_runs takes ScrapeRunsInput and returns a card whose body is [ScrapeRun].]

`ScrapeRun` rows with pages, rows, bytes, cost and time. The call needs the read grant at the brand rung.



| | |
|---|---|
| input | [ScrapeRunsInput](/concepts/scraperunsinput) |
| result | a card whose body is [ScrapeRun](/concepts/scraperun) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/ScrapeRun` |
| HTTP route | [`/v1/read/scrape_runs`](/reference/read/scrape_runs) |





| field | type | required | note |
|---|---|---|---|
| `template` | `id` | yes |  |
| `window` | [Window](/concepts/window) | yes |  |


---
title: "tool si.read.signals"
description: "a monitor, a subject, a kind or a strategy, and a window: the facts, with the coverage and the count not evaluable for the same window."
section: reference
address: /reference/tools/si-read-signals
contract: 0476e35e6e275db5
---

# tool si.read.signals

a monitor, a subject, a kind or a strategy, and a window: the facts, with the coverage and the count not evaluable for the same window.

[figure: Over MCP, si.read.signals takes SignalsInput and returns a card whose body is SignalsAnswer.]

the facts, with the coverage and the count not evaluable for the same window. The call needs the read grant at the strategy rung.



| | |
|---|---|
| input | [SignalsInput](/concepts/signalsinput) |
| result | a card whose body is [SignalsAnswer](/concepts/signalsanswer) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/SignalsAnswer` |
| HTTP route | [`/v1/read/signals`](/reference/read/signals) |





| field | type | required | note |
|---|---|---|---|
| `monitor` | `id` | no |  |
| `subject` | `id` | no |  |
| `kind` | [KindOfSignal](/concepts/kindofsignal) | no |  |
| `strategy` | `id` | no |  |
| `window` | [Window](/concepts/window) | yes |  |
| `catches` | `bool` | no | read catches instead |


---
title: "tool si.read.simulation_frame"
description: "Reads the frame of one simulation: The answer gives the trajectory of every stock, the gain of every loop, the sensitivity to every intervention, and the set of options that compares strategies laid over the same template."
section: reference
address: /reference/tools/si-read-simulation_frame
contract: 0476e35e6e275db5
---

# tool si.read.simulation_frame

Reads the frame of one simulation: The answer gives the trajectory of every stock, the gain of every loop, the sensitivity to every intervention, and the set of options that compares strategies laid over the same template.

[figure: Over MCP, si.read.simulation_frame takes SimulationFrameInput and returns a card whose body is MarketSimulationFrame.]

The answer gives the trajectory of every stock, the gain of every loop, the sensitivity to every intervention, and the set of options that compares strategies laid over the same template. The call needs the read grant at the brand rung.



| | |
|---|---|
| input | [SimulationFrameInput](/concepts/simulationframeinput) |
| result | a card whose body is [MarketSimulationFrame](/concepts/marketsimulationframe) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/MarketSimulationFrame` |
| HTTP route | [`/v1/read/simulation_frame`](/reference/read/simulation_frame) |





| field | type | required | note |
|---|---|---|---|
| `simulation` | `id` | yes |  |


---
title: "tool si.read.source_procedure"
description: "a source: its procedure at its version, the date of its last reading and whether it is stale."
section: reference
address: /reference/tools/si-read-source_procedure
contract: 0476e35e6e275db5
---

# tool si.read.source_procedure

a source: its procedure at its version, the date of its last reading and whether it is stale.

[figure: Over MCP, si.read.source_procedure takes SourceProcedureInput and returns a card whose body is SourceProcedure.]

its procedure at its version, the date of its last reading and whether it is stale. The call needs the read grant at the tenant rung.



| | |
|---|---|
| input | [SourceProcedureInput](/concepts/sourceprocedureinput) |
| result | a card whose body is [SourceProcedure](/concepts/sourceprocedure) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/SourceProcedure` |
| HTTP route | [`/v1/read/source_procedure`](/reference/read/source_procedure) |





| field | type | required | note |
|---|---|---|---|
| `source` | `id` | yes |  |


---
title: "tool si.read.speed_to_lead"
description: "Reads the delay from delivery to the first touch for one brand, over a window: The answer gives the measure's readings, with the population each was read over."
section: reference
address: /reference/tools/si-read-speed_to_lead
contract: 0476e35e6e275db5
---

# tool si.read.speed_to_lead

Reads the delay from delivery to the first touch for one brand, over a window: The answer gives the measure's readings, with the population each was read over.

[figure: Over MCP, si.read.speed_to_lead takes SpeedToLeadInput and returns a card whose body is SpeedToLead.]

The answer gives the measure's readings, with the population each was read over. The call needs the read grant at the brand rung.



| | |
|---|---|
| input | [SpeedToLeadInput](/concepts/speedtoleadinput) |
| result | a card whose body is [SpeedToLead](/concepts/speedtolead) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/SpeedToLead` |
| HTTP route | [`/v1/read/speed_to_lead`](/reference/read/speed_to_lead) |





| field | type | required | note |
|---|---|---|---|
| `brand` | `id` | yes |  |
| `window` | [Window](/concepts/window) | yes |  |


---
title: "tool si.read.strategy"
description: "a strategy, as of a date (`StrategyReadInput`): the `Strategy` with its life, its game, its graph of plays with each play's class and its reading, the experiments' shares and the frame of its last simulation."
section: reference
address: /reference/tools/si-read-strategy
contract: 0476e35e6e275db5
---

# tool si.read.strategy

a strategy, as of a date (`StrategyReadInput`): the `Strategy` with its life, its game, its graph of plays with each play's class and its reading, the experiments' shares and the frame of its last simulation.

[figure: Over MCP, si.read.strategy takes StrategyReadInput and returns a card whose body is Strategy.]

the `Strategy` with its life, its game, its graph of plays with each play's class and its reading, the experiments' shares and the frame of its last simulation. The call needs the read grant at the strategy rung.



| | |
|---|---|
| input | [StrategyReadInput](/concepts/strategyreadinput) |
| result | a card whose body is [Strategy](/concepts/strategy) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/Strategy` |
| HTTP route | [`/v1/read/strategy`](/reference/read/strategy) |





| field | type | required | note |
|---|---|---|---|
| `strategy` | `id` | yes |  |
| `as_of` | `date` | no |  |


---
title: "tool si.read.systems_models"
description: "Reads the systems models that fit one vertical or one kind of offering: Each template arrives with its readiness and the defect it carries named."
section: reference
address: /reference/tools/si-read-systems_models
contract: 0476e35e6e275db5
---

# tool si.read.systems_models

Reads the systems models that fit one vertical or one kind of offering: Each template arrives with its readiness and the defect it carries named.

[figure: Over MCP, si.read.systems_models takes SystemsModelsInput and returns a card whose body is [SystemsModelTemplate].]

Each template arrives with its readiness and the defect it carries named. The call needs the read grant at the tenant rung.



| | |
|---|---|
| input | [SystemsModelsInput](/concepts/systemsmodelsinput) |
| result | a card whose body is [SystemsModelTemplate](/concepts/systemsmodeltemplate) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/SystemsModelTemplate` |
| HTTP route | [`/v1/read/systems_models`](/reference/read/systems_models) |





| field | type | required | note |
|---|---|---|---|
| `vertical` | `id` | no |  |
| `kind_of_offering` | [KindOfOffering](/concepts/kindofoffering) | no |  |


---
title: "tool si.read.trajectory"
description: "a strategy or one move, and a window (`TrajectoryInput`): plan item to grounded move to outcome: each move with the items that carried it out, their readings and its effect."
section: reference
address: /reference/tools/si-read-trajectory
contract: 0476e35e6e275db5
---

# tool si.read.trajectory

a strategy or one move, and a window (`TrajectoryInput`): plan item to grounded move to outcome: each move with the items that carried it out, their readings and its effect.

[figure: Over MCP, si.read.trajectory takes TrajectoryInput and returns a card whose body is Trajectory.]

plan item to grounded move to outcome: each move with the items that carried it out, their readings and its effect. The call needs the read grant at the strategy rung.



| | |
|---|---|
| input | [TrajectoryInput](/concepts/trajectoryinput) |
| result | a card whose body is [Trajectory](/concepts/trajectory) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/Trajectory` |
| HTTP route | [`/v1/read/trajectory`](/reference/read/trajectory) |





| field | type | required | note |
|---|---|---|---|
| `strategy` | `id` | no |  |
| `move` | `id` | no |  |
| `window` | [Window](/concepts/window) | no |  |


---
title: "tool si.read.under_test"
description: "a subject or a scope, and the two dates: every hypothesis about it with its standing, its evidence for and against, the tests run and the tests owed, and what would settle each."
section: reference
address: /reference/tools/si-read-under_test
contract: 0476e35e6e275db5
---

# tool si.read.under_test

a subject or a scope, and the two dates: every hypothesis about it with its standing, its evidence for and against, the tests run and the tests owed, and what would settle each.

[figure: Over MCP, si.read.under_test takes UnderTestInput and returns a card whose body is [Hypothesis].]

every hypothesis about it with its standing, its evidence for and against, the tests run and the tests owed, and what would settle each. The call needs the read grant at the strategy rung.



| | |
|---|---|
| input | [UnderTestInput](/concepts/undertestinput) |
| result | a card whose body is [Hypothesis](/concepts/hypothesis) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/Hypothesis` |
| HTTP route | [`/v1/read/under_test`](/reference/read/under_test) |





| field | type | required | note |
|---|---|---|---|
| `about` | [UnitRef](/concepts/unitref) | no |  |
| `scope` | [Scope](/concepts/scope) | no |  |
| `standing` | `one of under test \| supported \| refuted \| cannot tell \| all` | no |  |


---
title: "tool si.read.unit"
description: "the kind, the id, the caller: the unit."
section: reference
address: /reference/tools/si-read-unit
contract: 0476e35e6e275db5
---

# tool si.read.unit

the kind, the id, the caller: the unit.

[figure: Over MCP, si.read.unit takes UnitRef and returns a card whose body is Unit.]

the unit. The call needs the read grant at the strategy rung.



| | |
|---|---|
| input | [UnitRef](/concepts/unitref) |
| result | a card whose body is [Unit](/concepts/unit) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/Unit` |
| HTTP route | [`/v1/read/unit`](/reference/read/unit) |





| field | type | required | note |
|---|---|---|---|
| `id` | `id` | yes |  |
| `kind` | [Kind](/concepts/kind) | yes |  |


---
title: "tool si.read.usage_statement"
description: "a period: the tenant's usage of the period by kind, priced, against the plan."
section: reference
address: /reference/tools/si-read-usage_statement
contract: 0476e35e6e275db5
---

# tool si.read.usage_statement

a period: the tenant's usage of the period by kind, priced, against the plan.

[figure: Over MCP, si.read.usage_statement takes UsageStatementInput and returns a card whose body is UsageStatement.]

the tenant's usage of the period by kind, priced, against the plan. The call needs the read grant at the tenant rung.



| | |
|---|---|
| input | [UsageStatementInput](/concepts/usagestatementinput) |
| result | a card whose body is [UsageStatement](/concepts/usagestatement) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/UsageStatement` |
| HTTP route | [`/v1/read/usage_statement`](/reference/read/usage_statement) |





| field | type | required | note |
|---|---|---|---|
| `period` | [Window](/concepts/window) | yes |  |


---
title: "tool si.read.value_chain"
description: "Reads the value chain of one vertical, with the brand whose participants are placed on it: The answer gives the chain's stocks and handovers with their counts, the participants on each stock, and the loops the templates name over it."
section: reference
address: /reference/tools/si-read-value_chain
contract: 0476e35e6e275db5
---

# tool si.read.value_chain

Reads the value chain of one vertical, with the brand whose participants are placed on it: The answer gives the chain's stocks and handovers with their counts, the participants on each stock, and the loops the templates name over it.

[figure: Over MCP, si.read.value_chain takes ValueChainInput and returns a card whose body is ValueChain.]

The answer gives the chain's stocks and handovers with their counts, the participants on each stock, and the loops the templates name over it. The call needs the read grant at the brand rung.



| | |
|---|---|
| input | [ValueChainInput](/concepts/valuechaininput) |
| result | a card whose body is [ValueChain](/concepts/valuechain) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/ValueChain` |
| HTTP route | [`/v1/read/value_chain`](/reference/read/value_chain) |





| field | type | required | note |
|---|---|---|---|
| `vertical` | `id` | yes |  |
| `brand` | `id` | no |  |
| `segment` | `id` | no |  |


---
title: "tool si.read.vertical"
description: "the vertical, or a brand whose vertical is meant: its chain by side with every stock's count and basis, its roles, its segments, its templates, its words and its rules."
section: reference
address: /reference/tools/si-read-vertical
contract: 0476e35e6e275db5
---

# tool si.read.vertical

the vertical, or a brand whose vertical is meant: its chain by side with every stock's count and basis, its roles, its segments, its templates, its words and its rules.

[figure: Over MCP, si.read.vertical takes VerticalInput and returns a card whose body is Vertical.]

its chain by side with every stock's count and basis, its roles, its segments, its templates, its words and its rules. The call needs the read grant at the brand rung.



| | |
|---|---|
| input | [VerticalInput](/concepts/verticalinput) |
| result | a card whose body is [Vertical](/concepts/vertical) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/Vertical` |
| HTTP route | [`/v1/read/vertical`](/reference/read/vertical) |





| field | type | required | note |
|---|---|---|---|
| `vertical` | `id` | no |  |
| `brand` | `id` | no |  |


---
title: "tool si.read.why"
description: "any unit: the chain of reasons, from this unit back to its first cause."
section: reference
address: /reference/tools/si-read-why
contract: 0476e35e6e275db5
---

# tool si.read.why

any unit: the chain of reasons, from this unit back to its first cause.

[figure: Over MCP, si.read.why takes WhyInput and returns a card whose body is WhyAnswer.]

the chain of reasons, from this unit back to its first cause. The call needs the read grant at the user rung.



| | |
|---|---|
| input | [WhyInput](/concepts/whyinput) |
| result | a card whose body is [WhyAnswer](/concepts/whyanswer) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/WhyAnswer` |
| HTTP route | [`/v1/read/why`](/reference/read/why) |





| field | type | required | note |
|---|---|---|---|
| `unit` | [UnitRef](/concepts/unitref) | yes |  |


---
title: "tool si.read.withheld"
description: "Reads the withheld count for one brand or one tenant: The answer gives the count by buyer profile and temperature, with the period and the limit it was read against."
section: reference
address: /reference/tools/si-read-withheld
contract: 0476e35e6e275db5
---

# tool si.read.withheld

Reads the withheld count for one brand or one tenant: The answer gives the count by buyer profile and temperature, with the period and the limit it was read against.

[figure: Over MCP, si.read.withheld takes WithheldInput and returns a card whose body is WithheldCount.]

The answer gives the count by buyer profile and temperature, with the period and the limit it was read against. The call needs the read grant at the brand rung.



| | |
|---|---|
| input | [WithheldInput](/concepts/withheldinput) |
| result | a card whose body is [WithheldCount](/concepts/withheldcount) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/WithheldCount` |
| HTTP route | [`/v1/read/withheld`](/reference/read/withheld) |





| field | type | required | note |
|---|---|---|---|
| `brand` | `id` | no |  |
| `tenant` | `id` | no |  |
| `period` | [Window](/concepts/window) | yes |  |


---
title: "tool si.session.cache"
description: "nothing, or a call to forget: what the app holds from earlier answers, by call and date, and when each expires."
section: reference
address: /reference/tools/si-session-cache
contract: 0476e35e6e275db5
---

# tool si.session.cache

nothing, or a call to forget: what the app holds from earlier answers, by call and date, and when each expires.

[figure: Over MCP, si.session.cache takes CacheInput and returns a card whose body is CacheView.]

what the app holds from earlier answers, by call and date, and when each expires. The call needs the read grant at the user rung.



| | |
|---|---|
| input | [CacheInput](/concepts/cacheinput) |
| result | a card whose body is [CacheView](/concepts/cacheview) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/CacheView` |
| HTTP route | [`/v1/session/cache`](/reference/session/cache) |





| field | type | required | note |
|---|---|---|---|
| `forget` | `text` | no | the call name and its input hash |


---
title: "tool si.session.my_grants"
description: "the caller, and a place: its permissions there, after all three narrowings."
section: reference
address: /reference/tools/si-session-my_grants
contract: 0476e35e6e275db5
---

# tool si.session.my_grants

the caller, and a place: its permissions there, after all three narrowings.

[figure: Over MCP, si.session.my_grants takes GrantsInput and returns a card whose body is [GrantRef].]

its permissions there, after all three narrowings. The call needs the read grant at the user rung.



| | |
|---|---|
| input | [GrantsInput](/concepts/grantsinput) |
| result | a card whose body is [GrantRef](/concepts/grantref) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/GrantRef` |
| HTTP route | [`/v1/session/my_grants`](/reference/session/my_grants) |





| field | type | required | note |
|---|---|---|---|
| `place` | [Scope](/concepts/scope) | yes |  |


---
title: "tool si.session.my_scopes"
description: "the caller: the scopes it reads, set on the database transaction before any query runs."
section: reference
address: /reference/tools/si-session-my_scopes
contract: 0476e35e6e275db5
---

# tool si.session.my_scopes

the caller: the scopes it reads, set on the database transaction before any query runs.

[figure: Over MCP, si.session.my_scopes takes Nothing and returns a card whose body is [Scope].]

the scopes it reads, set on the database transaction before any query runs. The call needs the read grant at the user rung.



| | |
|---|---|
| input | [Nothing](/concepts/nothing) |
| result | a card whose body is [Scope](/concepts/scope) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/Scope` |
| HTTP route | [`/v1/session/my_scopes`](/reference/session/my_scopes) |


---
title: "tool si.session.sign_in"
description: "nothing, or the tenant to sign in to: the way the browser was opened, then the caller as a view once the code came back; the refresh token goes to the keychain and never to the caller."
section: reference
address: /reference/tools/si-session-sign_in
contract: 0476e35e6e275db5
---

# tool si.session.sign_in

nothing, or the tenant to sign in to: the way the browser was opened, then the caller as a view once the code came back; the refresh token goes to the keychain and never to the caller.

[figure: Over MCP, si.session.sign_in takes SignInInput and returns a card whose body is Caller.]

the way the browser was opened, then the caller as a view once the code came back; the refresh token goes to the keychain and never to the caller. The call needs the read grant at the user rung.



| | |
|---|---|
| input | [SignInInput](/concepts/signininput) |
| result | a card whose body is [Caller](/concepts/caller) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/Caller` |
| HTTP route | [`/v1/session/sign_in`](/reference/session/sign_in) |





| field | type | required | note |
|---|---|---|---|
| `tenant` | `id` | no |  |
| `token` | `text` | no | an access token the identity provider issued, checked six ways at the face; never logged |


---
title: "tool si.session.sign_out"
description: "the session or the user: nothing."
section: reference
address: /reference/tools/si-session-sign_out
contract: 0476e35e6e275db5
---

# tool si.session.sign_out

the session or the user: nothing.

[figure: Over MCP, si.session.sign_out takes SignOutInput and returns a card whose body is Nothing.]

nothing. The call needs the read grant at the user rung.



| | |
|---|---|
| input | [SignOutInput](/concepts/signoutinput) |
| result | a card whose body is [Nothing](/concepts/nothing) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/Nothing` |
| HTTP route | [`/v1/session/sign_out`](/reference/session/sign_out) |





| field | type | required | note |
|---|---|---|---|
| `session` | `id` | no |  |
| `user` | `id` | no |  |


---
title: "tool si.session.whoami"
description: "a token, a key, or a run's identity: the caller, with its scopes and its access scopes."
section: reference
address: /reference/tools/si-session-whoami
contract: 0476e35e6e275db5
---

# tool si.session.whoami

a token, a key, or a run's identity: the caller, with its scopes and its access scopes.

[figure: Over MCP, si.session.whoami takes WhoAmIInput and returns a card whose body is Caller.]

the caller, with its scopes and its access scopes. The call needs the read grant at the user rung.



| | |
|---|---|
| input | [WhoAmIInput](/concepts/whoamiinput) |
| result | a card whose body is [Caller](/concepts/caller) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/Caller` |
| HTTP route | [`/v1/session/whoami`](/reference/session/whoami) |





| field | type | required | note |
|---|---|---|---|
| `token` | `text` | no | never logged |
| `key` | `id` | no |  |
| `run` | `id` | no |  |


---
title: "tool si.view.capabilities"
description: "nothing: the page."
section: reference
address: /reference/tools/si-view-capabilities
contract: 0476e35e6e275db5
---

# tool si.view.capabilities

nothing: the page.

[figure: Over MCP, si.view.capabilities takes Nothing and returns a card whose body is CapabilitiesPage.]

the page. The call needs the read grant at the user rung.



| | |
|---|---|
| input | [Nothing](/concepts/nothing) |
| result | a card whose body is [CapabilitiesPage](/concepts/capabilitiespage) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/CapabilitiesPage` |
| HTTP route | [`/v1/view/capabilities`](/reference/view/capabilities) |


---
title: "tool si.view.journey"
description: "a unit's id: its hops, back and forward."
section: reference
address: /reference/tools/si-view-journey
contract: 0476e35e6e275db5
---

# tool si.view.journey

a unit's id: its hops, back and forward.

[figure: Over MCP, si.view.journey takes JourneyInput and returns a card whose body is Journey.]

its hops, back and forward. The call needs the read grant at the user rung.



| | |
|---|---|
| input | [JourneyInput](/concepts/journeyinput) |
| result | a card whose body is [Journey](/concepts/journey) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/Journey` |
| HTTP route | [`/v1/view/journey`](/reference/view/journey) |





| field | type | required | note |
|---|---|---|---|
| `unit` | [UnitRef](/concepts/unitref) | yes |  |
| `depth` | `count` | no |  |


---
title: "tool si.view.oldest"
description: "a kind, a place, and how many: those units, each with its reason and since when."
section: reference
address: /reference/tools/si-view-oldest
contract: 0476e35e6e275db5
---

# tool si.view.oldest

a kind, a place, and how many: those units, each with its reason and since when.

[figure: Over MCP, si.view.oldest takes OldestInput and returns a card whose body is [Oldest].]

those units, each with its reason and since when. The call needs the read grant at the user rung.



| | |
|---|---|
| input | [OldestInput](/concepts/oldestinput) |
| result | a card whose body is [Oldest](/concepts/oldest) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/Oldest` |
| HTTP route | [`/v1/view/oldest`](/reference/view/oldest) |





| field | type | required | note |
|---|---|---|---|
| `kind` | [Kind](/concepts/kind) | yes |  |
| `place` | `text` | yes |  |


---
title: "tool si.view.pairings"
description: "a scope: each pairing, with the units that lack their pair."
section: reference
address: /reference/tools/si-view-pairings
contract: 0476e35e6e275db5
---

# tool si.view.pairings

a scope: each pairing, with the units that lack their pair.

[figure: Over MCP, si.view.pairings takes PairingsInput and returns a card whose body is PairingsAnswer.]

each pairing, with the units that lack their pair. The call needs the read grant at the user rung.



| | |
|---|---|
| input | [PairingsInput](/concepts/pairingsinput) |
| result | a card whose body is [PairingsAnswer](/concepts/pairingsanswer) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/PairingsAnswer` |
| HTTP route | [`/v1/view/pairings`](/reference/view/pairings) |





| field | type | required | note |
|---|---|---|---|
| `scope` | [Scope](/concepts/scope) | yes |  |


---
title: "tool si.view.stocks"
description: "a part, a kind or a place, and a scope the caller holds: the six numbers for each."
section: reference
address: /reference/tools/si-view-stocks
contract: 0476e35e6e275db5
---

# tool si.view.stocks

a part, a kind or a place, and a scope the caller holds: the six numbers for each.

[figure: Over MCP, si.view.stocks takes StocksInput and returns a card whose body is [Stock].]

the six numbers for each. The call needs the read grant at the user rung.



| | |
|---|---|
| input | [StocksInput](/concepts/stocksinput) |
| result | a card whose body is [Stock](/concepts/stock) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/Stock` |
| HTTP route | [`/v1/view/stocks`](/reference/view/stocks) |





| field | type | required | note |
|---|---|---|---|
| `scope` | [Scope](/concepts/scope) | yes |  |
| `kind` | [Kind](/concepts/kind) | no |  |


---
title: "tool si.view.usage"
description: "a tenant, a kind, a provider, a window: quantity and cost by kind, by tenant, by provider and by period, with each provider's reconciliation state."
section: reference
address: /reference/tools/si-view-usage
contract: 0476e35e6e275db5
---

# tool si.view.usage

a tenant, a kind, a provider, a window: quantity and cost by kind, by tenant, by provider and by period, with each provider's reconciliation state.

[figure: Over MCP, si.view.usage takes UsageInput and returns a card whose body is UsageReport.]

quantity and cost by kind, by tenant, by provider and by period, with each provider's reconciliation state. The call needs the read grant at the tenant rung.



| | |
|---|---|
| input | [UsageInput](/concepts/usageinput) |
| result | a card whose body is [UsageReport](/concepts/usagereport) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/UsageReport` |
| HTTP route | [`/v1/view/usage`](/reference/view/usage) |





| field | type | required | note |
|---|---|---|---|
| `tenant` | `id` | no |  |
| `kind` | [KindOfUsage](/concepts/kindofusage) | no |  |
| `provider` | `text` | no |  |
| `window` | [Window](/concepts/window) | yes |  |


---
title: "tool si.view.waiting"
description: "the caller: notifications, oldest first."
section: reference
address: /reference/tools/si-view-waiting
contract: 0476e35e6e275db5
---

# tool si.view.waiting

the caller: notifications, oldest first.

[figure: Over MCP, si.view.waiting takes WaitingInput and returns a card whose body is [Notification].]

notifications, oldest first. Or nothing. The call needs the read grant at the user rung.



| | |
|---|---|
| input | [WaitingInput](/concepts/waitinginput) |
| result | a card whose body is [Notification](/concepts/notification) |
| read-only | yes |
| destructive | no |
| card address | `ui://scale-intelligence/cards/Notification` |
| HTTP route | [`/v1/view/waiting`](/reference/view/waiting) |





| field | type | required | note |
|---|---|---|---|
| `acknowledge` | `id` | no |  |


---
title: "tool si.work.backfill"
description: "a source, an access method, a window, a plane: the job; then partitions carrying the window."
section: reference
address: /reference/tools/si-work-backfill
contract: 0476e35e6e275db5
---

# tool si.work.backfill

a source, an access method, a window, a plane: the job; then partitions carrying the window.

[figure: Over MCP, si.work.backfill takes BackfillInput and returns a card whose body is Job.]

the job; then partitions carrying the window. The call needs the work grant at the brand rung.



| | |
|---|---|
| input | [BackfillInput](/concepts/backfillinput) |
| result | a card whose body is [Job](/concepts/job) |
| read-only | no |
| destructive | no |
| card address | `ui://scale-intelligence/cards/Job` |
| HTTP route | [`/v1/work/backfill`](/reference/work/backfill) |





| field | type | required | note |
|---|---|---|---|
| `source` | `id` | yes |  |
| `access_method` | `id` | yes |  |
| `window` | [Window](/concepts/window) | yes |  |
| `plane` | [Plane](/concepts/plane) | yes |  |
| `reading` | `text` | no | the hash of the procedure reading the backfill runs over, filled by the platform from the newest reading of the source through the way's connector; a caller leaves it empty |


---
title: "tool si.work.browse_open"
description: "a `BrowseOpenInput`: the session, opened, with its live view."
section: reference
address: /reference/tools/si-work-browse_open
contract: 0476e35e6e275db5
---

# tool si.work.browse_open

a `BrowseOpenInput`: the session, opened, with its live view.

[figure: Over MCP, si.work.browse_open takes BrowseOpenInput and returns a card whose body is BrowsingSession.]

the session, opened, with its live view. The call needs the work grant at the strategy rung.



| | |
|---|---|
| input | [BrowseOpenInput](/concepts/browseopeninput) |
| result | a card whose body is [BrowsingSession](/concepts/browsingsession) |
| read-only | no |
| destructive | no |
| card address | `ui://scale-intelligence/cards/BrowsingSession` |
| HTTP route | [`/v1/work/browse_open`](/reference/work/browse_open) |





| field | type | required | note |
|---|---|---|---|
| `strategy` | `id` | no |  |
| `identity` | `id` | no |  |
| `proxy_policy` | [ProxyPolicy](/concepts/proxypolicy) | no |  |
| `filter` | [ResourceFilter](/concepts/resourcefilter) | no |  |
| `live_view` | `bool` | yes |  |


---
title: "tool si.work.browse_take_over"
description: "a `BrowseTakeOverInput`: the session, driven by the person or handed back."
section: reference
address: /reference/tools/si-work-browse_take_over
contract: 0476e35e6e275db5
---

# tool si.work.browse_take_over

a `BrowseTakeOverInput`: the session, driven by the person or handed back.

[figure: Over MCP, si.work.browse_take_over takes BrowseTakeOverInput and returns a card whose body is BrowsingSession.]

the session, driven by the person or handed back. The call needs the work grant at the strategy rung.



| | |
|---|---|
| input | [BrowseTakeOverInput](/concepts/browsetakeoverinput) |
| result | a card whose body is [BrowsingSession](/concepts/browsingsession) |
| read-only | no |
| destructive | no |
| card address | `ui://scale-intelligence/cards/BrowsingSession` |
| HTTP route | [`/v1/work/browse_take_over`](/reference/work/browse_take_over) |





| field | type | required | note |
|---|---|---|---|
| `session` | `id` | yes |  |
| `hand_back` | `bool` | yes |  |


---
title: "tool si.work.build_facet"
description: "a facet kind, a seed (a predicate, a list of communities, or a place from the gazetteer), the scope, and the positive and negative controls: the facet's register with every candidate kept or dropped and its reason in words, its people, its pairs and its trend, and the facet not ready until its calibration is read."
section: reference
address: /reference/tools/si-work-build_facet
contract: 0476e35e6e275db5
---

# tool si.work.build_facet

a facet kind, a seed (a predicate, a list of communities, or a place from the gazetteer), the scope, and the positive and negative controls: the facet's register with every candidate kept or dropped and its reason in words, its people, its pairs and its trend, and the facet not ready until its calibration is read.

[figure: Over MCP, si.work.build_facet takes BuildFacetInput and returns a card whose body is Facet.]

the facet's register with every candidate kept or dropped and its reason in words, its people, its pairs and its trend, and the facet not ready until its calibration is read. The call needs the work grant at the strategy rung.



| | |
|---|---|
| input | [BuildFacetInput](/concepts/buildfacetinput) |
| result | a card whose body is [Facet](/concepts/facet) |
| read-only | no |
| destructive | no |
| card address | `ui://scale-intelligence/cards/Facet` |
| HTTP route | [`/v1/work/build_facet`](/reference/work/build_facet) |





| field | type | required | note |
|---|---|---|---|
| `facet_kind` | [FacetKind](/concepts/facetkind) | yes |  |
| `seed` | `text` | yes |  |
| `again` | `bool` | no | when true, the same seed is built again as new work, for a presence that changed since the last build; without it the same seed under the same measure is the same work and returns the run already made |
| `asked_again_at` | `time` | no | set by the tool from the ask, so the run's key differs; never typed by hand |
| `scope` | [Scope](/concepts/scope) | yes |  |


---
title: "tool si.work.cancel"
description: "the preview: nothing."
section: reference
address: /reference/tools/si-work-cancel
contract: 0476e35e6e275db5
---

# tool si.work.cancel

the preview: nothing.

[figure: Over MCP, si.work.cancel takes CancelInput and returns a card whose body is Nothing.]

nothing. The call needs the work grant at the strategy rung.



| | |
|---|---|
| input | [CancelInput](/concepts/cancelinput) |
| result | a card whose body is [Nothing](/concepts/nothing) |
| read-only | no |
| destructive | no |
| card address | `ui://scale-intelligence/cards/Nothing` |
| HTTP route | [`/v1/work/cancel`](/reference/work/cancel) |





| field | type | required | note |
|---|---|---|---|
| `task` | `id` | yes |  |


---
title: "tool si.work.download_set"
description: "a `DownloadInput`: `DownloadJob` rows, one per file."
section: reference
address: /reference/tools/si-work-download_set
contract: 0476e35e6e275db5
---

# tool si.work.download_set

a `DownloadInput`: `DownloadJob` rows, one per file.

[figure: Over MCP, si.work.download_set takes DownloadSetInput and returns a card whose body is [DownloadJob].]

`DownloadJob` rows, one per file. The call needs the work grant at the strategy rung.



| | |
|---|---|
| input | [DownloadSetInput](/concepts/downloadsetinput) |
| result | a card whose body is [DownloadJob](/concepts/downloadjob) |
| read-only | no |
| destructive | no |
| card address | `ui://scale-intelligence/cards/DownloadJob` |
| HTTP route | [`/v1/work/download_set`](/reference/work/download_set) |





| field | type | required | note |
|---|---|---|---|
| `addresses` | `[text]` | yes |  |
| `session` | `id` | no | the browsing session whose cookies serve |
| `identity` | `id` | no |  |
| `filter` | [ResourceFilter](/concepts/resourcefilter) | yes |  |
| `destination` | `one of bronze \| the workspace` | yes |  |


---
title: "tool si.work.download_set_control"
description: "a `DownloadControlInput`: the jobs in their new place."
section: reference
address: /reference/tools/si-work-download_set_control
contract: 0476e35e6e275db5
---

# tool si.work.download_set_control

a `DownloadControlInput`: the jobs in their new place.

[figure: Over MCP, si.work.download_set_control takes DownloadControlInput and returns a card whose body is [DownloadJob].]

the jobs in their new place. The call needs the work grant at the strategy rung.



| | |
|---|---|
| input | [DownloadControlInput](/concepts/downloadcontrolinput) |
| result | a card whose body is [DownloadJob](/concepts/downloadjob) |
| read-only | no |
| destructive | no |
| card address | `ui://scale-intelligence/cards/DownloadJob` |
| HTTP route | [`/v1/work/download_set_control`](/reference/work/download_set_control) |





| field | type | required | note |
|---|---|---|---|
| `job` | `id` | no |  |
| `set` | `id` | no |  |
| `control` | `one of pause \| resume \| cancel` | yes |  |


---
title: "tool si.work.lay_strategy"
description: "Lays one strategy on one twin, with the bounds of the run: The call returns the simulation whose interventions are the strategy's armed plays, then the frame."
section: reference
address: /reference/tools/si-work-lay_strategy
contract: 0476e35e6e275db5
---

# tool si.work.lay_strategy

Lays one strategy on one twin, with the bounds of the run: The call returns the simulation whose interventions are the strategy's armed plays, then the frame.

[figure: Over MCP, si.work.lay_strategy takes LayStrategyInput and returns a card whose body is MarketSimulation.]

The call returns the simulation whose interventions are the strategy's armed plays, then the frame. The call needs the work grant at the strategy rung.



| | |
|---|---|
| input | [LayStrategyInput](/concepts/laystrategyinput) |
| result | a card whose body is [MarketSimulation](/concepts/marketsimulation) |
| read-only | no |
| destructive | no |
| card address | `ui://scale-intelligence/cards/MarketSimulation` |
| HTTP route | [`/v1/work/lay_strategy`](/reference/work/lay_strategy) |





| field | type | required | note |
|---|---|---|---|
| `twin` | `id` | yes |  |
| `strategy` | `id` | yes |  |
| `horizon` | `duration` | no |  |
| `samples` | `count` | no |  |
| `seed` | `count` | no |  |


---
title: "tool si.work.local_procedure"
description: "a named procedure whose inputs are files in the workspace: a task run by the app with its steps in the app's own journal, resumable."
section: reference
address: /reference/tools/si-work-local_procedure
contract: 0476e35e6e275db5
---

# tool si.work.local_procedure

a named procedure whose inputs are files in the workspace: a task run by the app with its steps in the app's own journal, resumable.

[figure: Over MCP, si.work.local_procedure takes LocalProcedureInput and returns a card whose body is Task.]

a task run by the app with its steps in the app's own journal, resumable. The call needs the work grant at the strategy rung.



| | |
|---|---|
| input | [LocalProcedureInput](/concepts/localprocedureinput) |
| result | a card whose body is [Task](/concepts/task) |
| read-only | no |
| destructive | no |
| card address | `ui://scale-intelligence/cards/Task` |
| HTTP route | [`/v1/work/local_procedure`](/reference/work/local_procedure) |





| field | type | required | note |
|---|---|---|---|
| `procedure` | [NamedProcedure](/concepts/namedprocedure) | yes |  |
| `inputs` | `json` | no |  |


---
title: "tool si.work.mine"
description: "the caller: every run the caller started that is still running, each with what it has done, whether it may be stopped, and the tool that stops it."
section: reference
address: /reference/tools/si-work-mine
contract: 0476e35e6e275db5
---

# tool si.work.mine

the caller: every run the caller started that is still running, each with what it has done, whether it may be stopped, and the tool that stops it.

[figure: Over MCP, si.work.mine takes Nothing and returns a card whose body is MyWork.]

every run the caller started that is still running, each with what it has done, whether it may be stopped, and the tool that stops it. The call needs the work grant at the user rung.



| | |
|---|---|
| input | [Nothing](/concepts/nothing) |
| result | a card whose body is [MyWork](/concepts/mywork) |
| read-only | no |
| destructive | no |
| card address | `ui://scale-intelligence/cards/MyWork` |
| HTTP route | [`/v1/work/mine`](/reference/work/mine) |


---
title: "tool si.work.run_procedure"
description: "the procedure and its inputs: a task."
section: reference
address: /reference/tools/si-work-run_procedure
contract: 0476e35e6e275db5
---

# tool si.work.run_procedure

the procedure and its inputs: a task.

[figure: Over MCP, si.work.run_procedure takes RunProcedureInput and returns a card whose body is Task.]

a task. The call needs the work grant at the strategy rung.



| | |
|---|---|
| input | [RunProcedureInput](/concepts/runprocedureinput) |
| result | a card whose body is [Task](/concepts/task) |
| read-only | no |
| destructive | no |
| card address | `ui://scale-intelligence/cards/Task` |
| HTTP route | [`/v1/work/run_procedure`](/reference/work/run_procedure) |





| field | type | required | note |
|---|---|---|---|
| `procedure` | [NamedProcedure](/concepts/namedprocedure) | yes |  |
| `inputs` | `json` | no |  |


---
title: "tool si.work.search_fit"
description: "Searches for product-market fit from one end: an offering looking for its markets, or a concept looking for a market: The call returns the search as work, then the frame that holds what it settled."
section: reference
address: /reference/tools/si-work-search_fit
contract: 0476e35e6e275db5
---

# tool si.work.search_fit

Searches for product-market fit from one end: an offering looking for its markets, or a concept looking for a market: The call returns the search as work, then the frame that holds what it settled.

[figure: Over MCP, si.work.search_fit takes FitSearchInput and returns a card whose body is FitSearch.]

The call returns the search as work, then the frame that holds what it settled. The call needs the work grant at the brand rung.



| | |
|---|---|
| input | [FitSearchInput](/concepts/fitsearchinput) |
| result | a card whose body is [FitSearch](/concepts/fitsearch) |
| read-only | no |
| destructive | no |
| card address | `ui://scale-intelligence/cards/FitSearch` |
| HTTP route | [`/v1/work/search_fit`](/reference/work/search_fit) |





| field | type | required | note |
|---|---|---|---|
| `brand` | `id` | yes |  |
| `from_end` | `one of an offering \| a concept` | yes |  |
| `offerings` | `[id]` | yes |  |
| `concept` | `text` | no |  |
| `candidate_verticals` | `[id]` | yes |  |


---
title: "tool si.work.simulate_market"
description: "Runs one systems model template over a market, with the interventions to try and the bounds of the run: The call returns the simulation as work, then the frame that holds what it reached."
section: reference
address: /reference/tools/si-work-simulate_market
contract: 0476e35e6e275db5
---

# tool si.work.simulate_market

Runs one systems model template over a market, with the interventions to try and the bounds of the run: The call returns the simulation as work, then the frame that holds what it reached.

[figure: Over MCP, si.work.simulate_market takes MarketSimulationInput and returns a card whose body is MarketSimulation.]

The call returns the simulation as work, then the frame that holds what it reached. The call needs the work grant at the brand rung.



| | |
|---|---|
| input | [MarketSimulationInput](/concepts/marketsimulationinput) |
| result | a card whose body is [MarketSimulation](/concepts/marketsimulation) |
| read-only | no |
| destructive | no |
| card address | `ui://scale-intelligence/cards/MarketSimulation` |
| HTTP route | [`/v1/work/simulate_market`](/reference/work/simulate_market) |





| field | type | required | note |
|---|---|---|---|
| `template` | [SystemsModelTemplate](/concepts/systemsmodeltemplate) | yes |  |
| `vertical` | `id` | yes |  |
| `segment` | `id` | no |  |
| `brand` | `id` | no |  |
| `interventions` | [Intervention](/concepts/intervention) | yes |  |
| `horizon` | `duration` | no | the template's when absent |
| `samples` | `count` | no | the parameter's when absent |
| `seed` | `count` | no |  |


---
title: "tool si.work.status"
description: "the task: its progress."
section: reference
address: /reference/tools/si-work-status
contract: 0476e35e6e275db5
---

# tool si.work.status

the task: its progress.

[figure: Over MCP, si.work.status takes StatusInput and returns a card whose body is Task.]

its progress. Or nothing. The call needs the work grant at the strategy rung.



| | |
|---|---|
| input | [StatusInput](/concepts/statusinput) |
| result | a card whose body is [Task](/concepts/task) |
| read-only | no |
| destructive | no |
| card address | `ui://scale-intelligence/cards/Task` |
| HTTP route | [`/v1/work/status`](/reference/work/status) |





| field | type | required | note |
|---|---|---|---|
| `task` | `id` | yes |  |
| `do` | `one of watch \| answer \| stop` | yes |  |
| `answer` | [TaskQuestion](/concepts/taskquestion) | no |  |


---
title: "For models"
description: "A language model reads this site through the index for models, the full Markdown copy, the Markdown twin of every page, the API document, the MCP manifest and the Context7 configuration."
section: for-models
address: /for-models
contract: 0476e35e6e275db5
---

# For models

A language model reads this site through the index for models, the full Markdown copy, the Markdown twin of every page, the API document, the MCP manifest and the Context7 configuration.

[figure: A model reads the index for models first, then the Markdown twin of each page that it needs.]

| file | address | contents |
|---|---|---|
| the index for models | [/llms.txt](/llms.txt) | a heading with the platform's name, a paragraph about the platform, then the sections, and every page as a link with a one-line description |
| the full Markdown copy | [/llms-full.txt](/llms-full.txt) | every page's Markdown, in reading order |
| the Markdown twin | the page's address with `.md` appended | the page's Markdown, with the same front matter, headings and examples |
| the API document | [/openapi.json](/openapi.json) | the served OpenAPI document at contract 0476e35e6e275db5, byte for byte |
| the MCP manifest | [/mcp-manifest.json](/mcp-manifest.json) | the served manifest at contract 0476e35e6e275db5, byte for byte |
| the Context7 configuration | `context7.json` at the repository's root | the docs folder and its rules for readers |
| the MCP resource | `docs://{address}` on the MCP server | the page's twin, which the MCP server serves to a connected agent without a key |


---
title: "Changelog"
description: "Every release of the platform, with its receipt. The release process generates this page. No release has shipped yet, and this site is built from the design's contract."
section: changelog
address: /changelog
contract: 0476e35e6e275db5
---

# Changelog

Every release of the platform, with its receipt. The release process generates this page. No release has shipped yet, and this site is built from the design's contract.

[figure: A change becomes a release after its checks pass, and the release adds a row to this page.]

| release | date | contract | receipt |
|---|---|---|---|
| none yet | | 0476e35e6e275db5cc06c238bc65f93c6070e2723b94b2b8dd78a66ec5306c3a, fixed on 2026-09-30 | the design's own checks at commit 037c0db of the design package |