Evidence: Resolved, not registered

A platform meeting the agent for the first time admits it by resolving the authority.

What lets an authorisation server trust an agent it meets for the first time?

  • 3Claims on this page
  • 10Artefacts behind them
  • 7Reads you can run here

Back to Resolved, not registeredEvery claim on this site

The chain the platform walks

Two authorities vouch for one agent. The platform admits through one.

Read: agent to anchor

Verify: pinned key to agent

Records Assistant

Published by Raidiam Connect

  1. Statement about the agent

    • records.read
    • transfer.status

    Aldercross authority

    Aldercross Scheme Authority

    Aldercross scheme federation

    Pinned for marks only

  2. Statement about the agent

    • records.read
    • records.annotate
    • transfer.initiate
    • transfer.status

    Tarnbrook authority

    Tarnbrook Financial Group

    Tarnbrook federation

    Pinned for admission

The client the platform builds

From the Tarnbrook chain.

authorization_details_types
records.readrecords.annotatetransfer.initiatetransfer.status
token_endpoint_auth_method
private_key_jwt

Only the authority's statement carries policy.

The five reads

The agent asserts no types of its own.

The platform reads from the agent through authority_hints in the order the agent lists them, then verifies from the anchor key it holds in configuration back to the agent. It walks both chains and admits through the one it pins for admission.

OpenID Federation (open standard) gives every entity a signed configuration about itself, and gives a superior a signed statement about each entity beneath it. The API platform performs the walk itself, with the resolver every consumer on this estate shares, and the pin is the pair of anchor identifier and key.

Each anchor's statement about its authority carries no policy, so the folded client is the Tarnbrook statement's policy, every parameter of it: the four detail types, the grant types, the backchannel delivery mode, the registration type and private_key_jwt. The value operator sets each of them.

The five reads

Each read is an unauthenticated GET. The chain figure links nine documents; three of them are the first three reads below. The fourth read is linked from the bound figure, and the fifth is linked here.

Who is asking. The agent's own configuration. Look for client_name Records Assistant, two authority_hints with Aldercross first, and five trust marks: four from the Tarnbrook domain and one from the Aldercross scheme.

Who vouches for it. The Tarnbrook authority's statement about the agent. Look for metadata_policy, and the four detail types it sets.

What a second domain says. The Aldercross authority's statement about the same agent. Look for two detail types where the first domain sets four.

What the resource bounds. The transfers resource's own page. Look for Limits, per transaction, GBP 1000.00.

Whether the platform admits. The platform's health answer. Look for admitting true and both anchor pins loaded. Read on 29 September 2026.

What the platform checks before it admits

The API platform From check 3, the first failure refuses.
  1. The walk

    1. Check 1Agent key
    2. Check 2Admission chain
  2. The admitting chain

    1. Check 3One federation
    2. Check 4Policy fold
    3. Check 5Envelope
  3. The mark

    1. Check 6Mark present
    2. Check 7Mark signature
    3. Check 8Lifecycle
A client, from the signed answerHeld until a lifetime ends, then resolved again.
The name each check refuses with
  1. Check 1no_chain_to_pinned_anchorThe agent's configuration verifies under the keys its authorities vouch for. If it does not, every chain fails.
  2. Check 2anchor_not_for_admissionEach hop verifies up to the anchor pinned for admission. A failed hop drops its own chain; the Aldercross chain still closes, so the platform answers with this name.
  3. Check 3authority_multiple_membershipsThe authority names one anchor, so the policy is one federation's.
  4. Check 4policy_conflictThe policies on the chain combine without conflict.
  5. Check 5policy_violationThe agent's own metadata stays inside the folded policy.
  6. Check 6accreditation_missingThe agent carries a mark the platform requires, tarnbrook.agent.member or tarnbrook.enforcement.point.
  7. Check 7accreditation_unverifiedThe mark verifies under its issuer's keys.
  8. Check 8accreditation_withdrawnThe issuer's status endpoint answers active. If it cannot be read, a mark read active in the last 300 seconds still counts.

The mark is checked on the agent itself.

Mark status, and how long the client is held

Its authority lists it directly, so no superior is involved.

A failed hop drops only its own chain, so the name the platform answers with depends on what survives the walk. The figure shows the checks this agent meets. The resolver can also answer accreditation_issuer_not_accepted, accreditation_unconfirmed when a status endpoint cannot be read and no recent active answer is held, and authority_unreachable when a document cannot be fetched at all.

A consumer holding an accreditation mark asks the issuing authority for its current status and receives a signed answer. The query is a form post of the mark itself. Observed

The platform holds the client it built until the shortest of three windows ends: its resolution cache, the earliest expiry on the chain, and its mark status cache. Then it resolves again.

Three ceilings, from the outside in

1

Registered

The Tarnbrook authority

  • records.read
  • records.annotate
  • transfer.initiate
  • transfer.status
2

Attested

A copy of ring 1: no attestation

3

Granted

What the agent requests

  • Read recordsrecords.read
  • Annotate a recordrecords.annotate
  • Check a transfertransfer.status
  • Initiate a transfer of 1000.00 GBPtransfer.initiateNoor Haddad approves
  • Initiate a transfer from a held account of 1000.00 GBPtransfer.initiateDara Nolan approves

Every request is tested against all three, from the outside in.

How the three are built and compared

A refusal names the first ceiling a request falls outside. apps/reference-op/src/grants.ts builds the ceilings and apps/reference-op/src/containment.ts compares them. The registered ceiling is the client the chain produced. The attested ceiling is narrowed by an attestation where a copy presents one, which use case 4 teaches; with none, grants.ts copies the registered types into it. The granted ceiling is the types the agent requests. For a task that moves value, a person approves it: the approval form offers the amount the agent asked for, and the person sets the value the token carries.

The bound the resource publishes

What the resource permits, per transaction

1000.00 GBP

Published on the resource's own page.

Deployment evidence

A request above that bound

5000.00 GBP

Sent under a grant of 1000.00 GBP.

GBP 5,000.00 exceeds the granted ceiling of GBP 1,000.00. Nothing moved.

The resource's own words and money format. Not read from a call.

Deployment evidence

What this page proves

Each claim, its label and the artefacts behind it.

Role rows as the source of published policy

Observed

Metadata policy on the subordinate statement is projected from role rows on the governed record.

The rest of the statement

The rows set on the role appear as the policy operators in the authority's statement about the entity.

Lifecycle stage
Govern
Lives in
Raidiam Connect
Checked by
Test verification:3b
Artefacts cited
2

This claim on the evidence page

The working

What the figures above leave to words.

What it means for the business

If every platform needs its own client record for every agent, each new agent is another relationship somebody maintains, on every platform it will reach. Here the platform holds no record at all. It reads what the authority signed, and the figures above draw each step of that read.

The platform on this route is a reference platform Raidiam wrote. It stands in for the authorisation servers you already run. What a platform of yours needs to do the same is set out on what a platform needs.

Ten terms
anchor
The root entity of a trust domain whose key a consumer pins from configuration.
authority
A Connect entity that publishes signed subordinate statements, marks and policy about the entities it governs.
trust domain
The set of entities that chain to one anchor.
entity configuration
The self signed statement an entity publishes at its own identifier.
subordinate statement
The statement a superior signs about a subordinate: keys, policy, marks.
trust mark
The signed projection of an active accreditation, with a status endpoint.
envelope
The set of authorization detail types and grant types an authority permits an agent to request. The registered ceiling.
resolve
Walk the chain from a leaf to a pinned anchor and fold the policy.
pin
The anchor key a consumer holds in configuration, written at deploy time, as the pair of anchor identifier and key.
recognition
The governed act by which an authority becomes a superior of an entity that already publishes its own configuration, minting nothing.

Check it against the running estate

Every surface this use case touches, and the host that answers for it.

The API platformapi.agents.showcase.raidiam.io Raidiam Connectweb.directory.showcase.raidiam.io The records resourcerecords.agents.showcase.raidiam.io The transfers resourcetransfers.agents.showcase.raidiam.io

Which of your platforms would resolve first, and what would it pin?

Ninety minutes, on the shape of your estate: which systems resolve first, which anchor each pins, and which key each party holds.

Book a working session