# How controls work

Controls are optional. The account works in full without them. They cost $4 a month after a 14-day trial, plus $10 per 10,000 checks, which falls to $6 by volume.

## What controls add

An account with controls off already has limits. Prepaid credit caps what can be spent, logins stay in the vault, incoming content is scanned and flagged, and revoking an agent stops it.

With controls on, STACK checks each action of an agent against a policy you set, before the action runs. The action is allowed, held for your approval or refused. A check that returns a verdict is charged once, whether it allows or refuses. You choose which kinds of action are checked, and a kind you leave out is neither checked nor charged.

Turning controls on changes nothing by itself. Each agent gets a policy equal to the access it already has, and nothing is refused until you tighten it. An agent can never change its own controls.

If the controls subscription lapses, controls switch off and nothing else is suspended. A budget you set earlier keeps applying.

- **Subscription:** $4 a month, 14-day trial
- **Checks, up to 1 million a month:** $10 per 10,000
- **Checks, 1 to 10 million:** $8.50 per 10,000
- **Checks, 10 to 50 million:** $7 per 10,000
- **Checks, above 50 million:** $6 per 10,000
- **A refused action:** The check is charged. The action is not

## Policies

A policy is a list of rules for one agent, with a default policy for the account. A policy only narrows what the agent’s connections already allow. Every list in it is an allowlist, and every number is a ceiling.

Spending rules set a ceiling for one action and totals for a day, a month and a job. Card and wallet payments can also be limited by merchant, by payee or by a category you define. When STACK cannot tell which merchant a payment belongs to, the strictest matching rule applies.

Recipient rules say where the account’s email, texts and calls may go: named addresses, whole domains or phone numbers. A reply-only rule lets an agent answer the sender of a message it received and nobody else. Connection rules say which connected services an agent may use and which operations on each.

Each kind of action, such as a model call, an email, a card checkout or a letter, can be allowed, held for review or refused. So can any action above an amount you set.

When a rule refuses, the agent is told which rule refused it and why. Tightening a policy applies at once. Loosening one needs your approval in a signed-in browser. You can try a call against a policy first: the simulation says whether the call would be allowed, held or refused, and counts nothing.

- **A policy covers:** One agent, with a default for the account
- **Spending totals:** A day, a month or a job, in money or in actions
- **Payment rules:** By merchant, payee or category
- **Kinds of action:** 34, each allowed, held or refused
- **Budget:** A monthly amount for each agent
- **History:** Numbered revisions, with who changed what

## Approvals

A rule set to review holds the action and tells the agent that it is waiting for a person. You, or an admin member, decide on the approval page in a signed-in browser. Once it is approved, the agent has one hour to repeat the exact call, and the approval works once.

A held card or wallet payment can also be approved from Telegram, a text message or Slack. This is off until you set two limits in the policy: the most for one payment and the most for a day. The prompt names the payment, expires after ten minutes and is accepted only from a chat identity you have confirmed in the browser.

Whoever controls that phone number or chat account can approve payments up to those limits. The limits are yours to keep small.

An agent can never approve its own action. Loosening controls, billing changes and deleting the account are approved in the browser only.

- **Who approves:** The owner or an admin member
- **Approval page:** Every held action
- **Telegram, text, Slack:** Held card and wallet payments, within your limits
- **Chat prompt:** Expires after 10 minutes
- **Approved action:** Repeated within 1 hour, once

## Runtime checks

Before an action of an agent reaches a provider, STACK runs the same checks in the same order. The first check that fails ends the action, and nothing after it runs.

Every account gets the first three. The Passport must be valid and not revoked. The agent must hold a grant to the connection, and the operation and its parameters must fit that grant. The request may go only to the hosts that belong to the connection.

Controls add the next four. The content of the request is scanned. The data rule compares what the request carries with what the agent has read from other services. The policy is then tried: first its rules, then whether the action is held for your approval, then its limits.

Only then is the action counted, paid for from credit where it costs money, and sent. The outcome is written to the record whether the action ran or was refused.

- **1. Passport:** Valid, and not revoked
- **2. Grant:** The connection, the operation and its parameters
- **3. Hosts:** Only those of the connection
- **4. Scan:** With controls: the content of the request
- **5. Data rule:** With controls: data from one service may not leave through another
- **6. Policy:** With controls: rules, then approval, then limits
- **7. Credit:** Enough to pay for the action
- **8. Record:** Written, whatever the outcome

## Flagged content

Everything an agent reads from outside is scanned for instructions aimed at it: mail, texts, voicemail, web pages, tool results, drive files, scanned post, Brain passages and what a caller says. Two layers run for every account. The first matches known patterns. The second decodes text that hides them, such as base64, look-alike characters and invisible characters.

With controls on, a third layer runs: a classifier that reads the content for attacks the patterns cannot see. Flagged content is then withheld from the agent by default, and you choose for each severity whether it is withheld or delivered. With controls off, the content is delivered with its flag.

On a benchmark of 1,087 samples the three layers score F1 0.87, with precision 0.98 and recall 0.79. Recall 0.79 means about one attack in five is not flagged, which is why the data rule below does not depend on the scan. The benchmark runs on every change to a detector, and a change that lowers the score does not merge.

The data rule follows what an agent has read. Data read from one service may not leave through another unless you have allowed that flow. With controls on, such a call is refused. With controls off it goes through and is recorded as a warning.

With controls on, personal data is redacted before a prompt reaches a model. Email addresses, phone numbers, card numbers, IBANs, national identifiers and IP addresses are each replaced by a marker.

- **Every account:** Pattern scan and decoding. Content is flagged
- **With controls:** The classifier. Flagged content is withheld
- **Benchmark:** F1 0.87, precision 0.98, recall 0.79
- **Samples:** 1,087, locked on 25 May 2026
- **Data rule:** Refuses with controls on, warns with controls off

## The record

Every action of every account is written to the record and kept for 365 days. With controls on you can read it, export it and verify it.

When agents handle customer data, money or production systems, the record of what happened often has to be used outside the engineering team. It may be needed for an incident investigation, a compliance review, an insurance claim or a legal dispute.

Each audit entry identifies the agent and Passport involved, the action, the outcome and the time. Entries are append-only and linked by hash. Important decisions and results are also stored as signed records, including Intents, approvals, checkpoints, detector findings, denials and outcomes.

Mission replay verifies those records and places them in time order. An Evidence Pack captures the records available when it was created, together with the hashes, signing keys and schemas needed to verify them outside STACK. A team member can add a signed review or incident dossier afterwards without changing the original record.

The record can also be delivered to an address of yours as it is written, in order and in signed batches. A pack is checked offline with the open verifier, @getstackrun/verify, without access to the STACK account.

## Deciding on your own server

You choose who decides. With hosted controls, STACK checks each action against your policy. With your own server, STACK asks your server and follows its answer.

STACK sends a signed request in the Standard Webhooks format and waits up to two seconds for a signed answer. The request carries the agent, the kind of action, its target, the amount and the stated purpose. It never carries message text, prompts, model output, card numbers or logins.

If your server does not answer in time, the action is refused. You can change that to allow, which counts as loosening and needs a browser approval. A server that keeps failing is paused for 15 seconds at a time. STACK never falls back to running without controls.

Each answer from your own server costs $2 per 10,000, with no controls subscription.

Reading the record, and having it delivered to an address of yours, still needs the controls subscription.

The control layer itself can also run on your own servers. The code is on GitHub.

- **Request:** Signed, Standard Webhooks format
- **Answer window:** 1.5 seconds by default, 2 at most
- **No answer:** Refused, unless you choose allow
- **Price:** $2 per 10,000 answers
- **Never sent:** Message text, prompts, card numbers, logins
- **The record:** Needs the controls subscription

## Controls only

You can use controls without the account’s services. Register an agent you already run and connect the services it uses. It uses the same plan and the same controls subscription, $19 and $4 a month, and you do not have to open any of the account’s services.

### Overview

Most agent deployments today are assembled from several separate systems: an identity provider, a secrets manager, an API gateway, policy checks and logging. Those products can all perform their own function correctly without sharing a common view of the work the agent was authorised to do. A request may therefore be valid at the gateway, and a credential may be valid at the secrets manager, even though the action itself has moved beyond the original job.

STACK gives each agent a Passport that carries its permitted services and actions, with references to the work and authority behind them. For an automated fleet, an operator approves the available access once. Each Mission then requests the part needed for a particular job, and STACK issues a Passport within those limits. Credential use, runtime decisions and the resulting record stay connected while the agent works. The same records can be used to stop the work or reconstruct what happened.

### Passport

A Passport is the signed permission an agent presents when it acts. It identifies the agent and names the connections and actions it may use, any restrictions on the request and when access expires. For a fleet Mission, STACK derives this permission from the access approved for that job. The Passport also refers to the Mission, Authority and identity records behind it. Identity evidence remains encrypted outside the Passport.

STACK can add signed claims to the Passport record as the agent works. A claim can record an intention, an approval, a checkpoint, a detector finding or a result. The audit log shows which claims applied when each event occurred.

A Passport lasts 15 minutes by default and never longer than one hour. A delegated Passport cannot exceed the access of its parent, and delegation stops after four hops. A receiving service can verify the signature without calling STACK. Requests checked by STACK also confirm that the Passport, agent, Authority, service connection and referenced identity records are still valid. Revocation blocks the next request and any Passport delegated from it. The claims and audit history are retained.

### Missions

Useful work rarely happens in a single request. A support case, an onboarding task or a production change may require an agent to use several systems over minutes or hours. When those requests are handled separately, it becomes difficult to tell whether the agent is still doing the work that was approved.

A Mission defines the job and the access it needs. A support update might need one connected Slack account, permission to post in channel C123 and a limit of 20 calls in 15 minutes. STACK checks that request against the operator’s approved fleet policy, records the permitted access in the Mission and issues the agent a Passport for it. An allowed Mission can start without another approval.

The Mission keeps the limits and record of the work together across calls and Passport renewals. A new Passport does not reset the allowance. The work ends when the Mission is completed, expires or is revoked.

### Authority

When an agent works in a customer account or production system, someone remains responsible for the access it uses. Most integrations infer that responsibility from the person who created an API key or connected an account. That does not show what they approved, which agent received the access or how long it should last.

STACK records the named approver, the person or organisation they are acting for, the agent they approved, where it may act, and the limits and expiry. The agent cannot approve itself or widen that approval.

### Identity

Agent deployments rely on several forms of identity. An application may know which user connected an account, the runtime may have its own machine identity, and the agent may still call other systems with a shared API key. These records are usually held separately, making it difficult to establish which agent made a request and who or what was behind it.

STACK links an agent to identity checks from Stripe Identity, account records from Okta, Auth0 or Microsoft Entra, and workload identity from SPIFFE, SPIRE or WIMSE. The Passport carries references to those records without exposing the underlying details.

A receiving organisation can request specific identity information when it needs it. STACK sends only what has been approved, signed and encrypted for that recipient. The recipient can verify the response itself, while the agent never sees the identity data.

### Credential access

Most agent deployments connect to external systems with API keys and access tokens. These credentials are often kept inside the agent runtime, where they can be read and reused by anything running in the same environment. The access granted to the runtime may therefore be much broader than the work assigned to the agent.

STACK keeps credentials outside the runtime and places a proxy between the agent and each connected service. Before adding the credential, the proxy checks the Passport, the Mission’s current state and the request itself. The action and its parameters must fit the approved access and remaining allowance. A request outside those limits is refused before the credential is used.

Supported OAuth connections renew their access tokens automatically. If the service requires fresh consent, STACK asks the operator to reconnect it. For writes, a stable operation handle prevents an unchanged retry from sending the request again. STACK returns the stored permitted response when available and keeps an uncertain result marked as unknown.

LLM use is handled through a separate gateway for Anthropic, OpenAI and OpenRouter. It keeps provider credentials outside the runtime and links each call to the relevant agent, Passport and Mission. Provider, model, token use and cost are recorded. Configured PII redaction removes recognised personal identifiers before a prompt is sent, while prompt and response scans can block injection attempts and credential leaks. This allows organisations to make external models available for everyday work without relying on every employee or agent to identify and remove those values first.

### Runtime checks

Permissions are only useful if they are applied to the request that reaches a real system. Before each protected action, STACK checks the current Passport and the records behind it, the exact request, the data it carries and where it is going.

A fleet policy determines which requests can run automatically, which require review and which are denied. Allowed work continues within the Mission and shared fleet limits. A reviewer can approve one exact exceptional request without giving the rest of the fleet more access. Expanding the fleet’s standing permissions requires a separate policy approval.

Each agent has an accountability mode. In enforced mode, some detector findings can stop a request or remove unsafe content from a response, and the agent must submit checkpoints and checkout. Logged mode keeps those reports and detector findings without interrupting the current request. Standard mode keeps the Passport and proxy checks but does not use checkpoints or checkout review.

Twenty-seven detectors examine requests, responses, delegation, checkpoints, credential use and changes in behaviour. Seventeen run during execution. Ten compare the completed record with the Mission, checkpoints and checkout report.

### Evidence

When agents handle customer data, money or production systems, the record of what happened often has to be used outside the engineering team. It may be needed for an incident investigation, a compliance review, an insurance claim or a legal dispute.

Each audit entry identifies the agent and Passport involved, the action, the outcome and the time. Entries are append-only and linked by hash. Important decisions and results are also stored as signed records, including Intents, approvals, checkpoints, detector findings, denials and outcomes.

Mission replay verifies those records and places them in time order. An Evidence Pack captures the records available when it was created, together with the hashes, signing keys and schemas needed to verify them outside STACK. A team member can add a signed review or incident dossier afterwards without changing the original record.

### Revocation

An operator can revoke one Passport and every Passport delegated from it without stopping the agent’s other sessions. The operator can also revoke a full session, every active Passport held by the agent, or the Authority that approved the access. An operator can also revoke a fleet policy or remove one agent’s membership. STACK then rejects new calls and Passport renewals that depend on that access.

A Passport is a separate signed authorisation. A session links the original Passport to any replacements and delegated Passports created during the same run. Blocking the agent revokes every active Passport and prevents another from being issued until a human unblocks it. Revoked Passports remain revoked.

STACK denies the next checked request before it reaches the external service. We measured 10 milliseconds using the real Redis path. If an identity claim or Mission becomes invalid, STACK revokes the Passport chain that depends on it. A service that verifies only the Passport signature must check revocation separately or wait for the Passport to expire.

### Drop-offs

Drop-offs are for work that needs to move from one agent to another without putting both agents in the same database, queue or conversation. An agent can hand the state of a session to the agent taking over the next shift, or pass a structured result to the next agent in a workflow.

The producer, consumer, schema and expiry are set before the transfer begins. A Drop-off accepts one payload and allows one collection. STACK rejects data that does not match the schema, encrypts accepted data while it waits and releases it only to the named consumer.

The payload is deleted after collection or expiry. The transfer record remains, including its producer, consumer, timestamps and payload hash. If the transfer forms part of a Mission, that relationship is recorded as well.

### Skills

Most specialist capabilities are built directly into the agent that uses them. Reusing one elsewhere usually means rebuilding the integration or giving another operator access to the underlying code. STACK Skills are published separately and can be used by any agent with the required access.

The publisher defines the input and output, where the Skill runs, the trust level it requires and the price of an invocation. Once STACK is connected through MCP, agents can find and use Skills directly from Claude Code, Codex or Cursor. Skills are also available through the TypeScript and Python SDKs, and operators can manage them through the CLI.

STACK checks the agent’s access and the buyer’s trust level, then validates the input and output against the publisher’s schemas. Publishers set their own prices. Paid invocations are charged to the buyer’s STACK Wallet, separately from the account subscription. STACK’s commission is 15% of the listed price, the same for every publisher.

### Teams and interfaces

A STACK account can be shared without giving every person the owner’s access. Each member has their own sign-in, role and list of approved services, so administrators can decide which connected systems they may use. A service can use one connection shared across the account, or a separate connection for each member. With separate connections, STACK routes each person’s requests through their own credential. Their actions remain attributed to them after access is removed.

Teams can use an existing OIDC provider, including Okta or Microsoft Entra, for SSO. Members receive a default STACK role on first sign-in and use their company identity. Removing a member disables their access and revokes their live OAuth sessions without deleting the earlier record.

Agents and applications can use the same account through MCP, the CLI, the TypeScript or Python SDK, or the REST API. After a service is connected and a fleet policy is approved, trusted agents can enroll, start Missions and renew their access through these interfaces. Per-agent signing keys keep the operator credential out of the agent runtime.

## $4 a month after a 14-day free trial.
