# Action Assurance (/docs/connectors/assurance)
An action's **assurance tier** answers one question: how far should you trust
this action to do what it says? It is a declaration with evidence behind it, an
author, and a shelf life — not a permanent label.
Assurance is one of four independent axes an action carries. It is not
availability, not runtime status, and — the confusion worth naming early — not
price. A free action can be certified; a premium one can be community-maintained.
Set `connector_assurance.enabled: true` to construct the assurance resolver and
project the tier onto catalog reads. While disabled — the default — no
declaration is resolved and every action reports **community**.
`require_certified_for_agents` is separately default-off. Leave it false and
agent callers are admitted exactly as they are today; set it true and an
agent-initiated action below the certified bar is refused.
## Two tiers, and why there is no third [#two-tiers-and-why-there-is-no-third]
The default. Contributed or ported, executable, but not verified to the certified bar. Also what every unknown, expired, or revoked declaration resolves to.
Maintained to a documented bar, with evidence on file, an author, and a claim that can lapse.
A third tier would have to mean *partially verified*, and a partial claim is read
as a full one far more often than it is read carefully. Decay is already
expressible: a certification can expire, and it can be revoked. Those are states
with dates attached, which is more useful than a middle label with none.
## What a certified claim carries [#what-a-certified-claim-carries]
A tier on its own is an assertion. The declaration records what justifies it, so
a reviewer can decide whether the claim was warranted rather than taking it on
faith.
| Field | What it records |
| ------------------------------ | -------------------------------------------------------------------------------------------------------------------------------- |
| `CertifiedBy` | The team or automation that made the claim |
| `CertifiedAt` | When it was made |
| `ContractTestsPassed` | Whether the provider's contract suite passed at certification |
| `ConformanceRunRef` | The conformance run backing the claim |
| `CanaryStatus`, `LastCanaryAt` | The last synthetic-canary verdict and when it ran |
| `SemanticsComplete` | Whether the action declares mutation class, idempotency, retry, and approval, so a caller — human or agent — can reason about it |
| `ProvenanceLabel` | Where the action came from, mirroring the provider's `upstream.yaml` |
| `Deprecated` | The action's deprecation state when the claim was made |
Evidence is an audit trail, not an input. The declared tier is authoritative; the
evidence is what you inspect when deciding whether to keep honoring it. A stale
canary is a reason to let a certification lapse rather than renew it.
## Nothing resolves upward [#nothing-resolves-upward]
Every route that fails to produce a valid, in-force, certified declaration ends
at community. There is no path — including an error path — that yields a stronger
claim than the data supports.
```mermaid
flowchart TD
A[Resolve assurance] --> B{Feature enabled?}
B -- no --> C[community]
B -- yes --> D{Declaration found?}
D -- none --> C
D -- store unreadable --> C
D -- found --> E{Revoked?}
E -- yes --> C
E -- no --> F{Expired?}
F -- yes --> C
F -- no --> G{Tier value valid?}
G -- no --> C
G -- yes --> H[declared tier]
```
Expiry and revocation are applied **at read time**, not by a background sweeper.
The row stays readable, so an auditor can still see who claimed what and why,
while the tier it reports downgrades the instant the claim lapses. There is no
window in which a lapsed certification still reads as valid, and no job to fall
behind.
The same downgrade runs again at projection time, so a stale certified claim
cannot reach the catalog API even if it survived elsewhere.
## Requiring certified for agents [#requiring-certified-for-agents]
`require_certified_for_agents` lets an operator demand the certified bar before
an agent worker auto-executes a connector action. Two properties matter:
* **No minimum demanded costs nothing.** When no minimum is set the gate admits
without consulting the store at all — no query, no latency on the default path.
* **A gate that cannot verify does not admit.** An unreadable declaration refuses
rather than falling through. Failing closed is the only safe direction for a
trust check.
An unknown tier satisfies no minimum, so a malformed value can never pass.
## Assurance is not price [#assurance-is-not-price]
The two axes are kept apart structurally, not by convention: separate tables,
separate resolvers that never read each other, separate proto fields, and
vocabularies with no shared values. `ActionPricing.tier` (`free`, `included`,
`standard`, `premium`, `metered`) is a **commercial** tier and carries no trust
meaning whatsoever.
Read them independently. "Certified and free" and "premium and community" are
both ordinary combinations.
## Where to go deeper [#where-to-go-deeper]
The money axis — the two-cost invariant, precedence, and the charge-policy matrix.
The contract suites, conformance runs, and canaries that produce the evidence.
The governed surface an agent worker acts through.