# MeaningSystem — Agent Guide

**Public application:** `https://www.meaningsystem.io`  
**Authenticated run endpoint:** `POST https://www.meaningsystem.io/v1/run`  
**Canonical agent manifest:** `https://api.maenen.ai/.well-known/maenen-agent.json`  
**Shared pricing manifest:** `https://www.meaningsystem.io/well-known/maenen-pricing.json`

MeaningSystem provides bounded, governed preset routes over public Maenen capabilities. This guide describes the MeaningSystem application boundary. The local pricing JSON is a packaged copy of the shared Maenen pricing contract; endpoint schemas are described by the published endpoint documentation and versioned machine contracts.

This repository copy is a locally qualified release-candidate guide, not deployment evidence. Before a real call, confirm that the public URL returns this guide rather than a redirect, parking page, or generic HTML response, and verify the public route catalogue and deployed schema.

## Route selection and authority

An agent may explicitly call a public route by supplying its published `route_id` to `POST /v1/run`. An agent may also ask `POST /v1/run/suggest` to assess route fit.

A suggestion may assess and recommend an eligible public route, but it does not execute the route and requires confirmation before `/v1/run`. Automatic selection may not trigger mutating Trust or Trust-Transact actions. Evidence returned by Trust services informs a decision; it does not create authority to mutate a listing, transaction, profile, passport, artifact, or other trust record.

Use only route IDs listed in the shared manifests. Do not infer an unpublished operation from a route name or stage.

## Operating endpoints

| Purpose | Endpoint | Execution and cost rule |
|---|---|---|
| Preflight Alignment | `POST https://www.meaningsystem.io/v1/agent/preflight` | Free, authenticated pre-run analysis; does not execute `/v1/run`. |
| Suggest a route | `POST https://www.meaningsystem.io/v1/run/suggest` | Recommendation only; no route execution and no execution charge. |
| List public routes | `GET https://www.meaningsystem.io/v1/orchestraitor/public/routes` | Discovery only; use the returned IDs. |
| Execute a selected route | `POST https://www.meaningsystem.io/v1/run` | Bearer-authenticated; selected-route pricing applies. |

Send credentials only as accepted by the deployed contract, normally `Authorization: Bearer <api_key>`. Never put a key in a URL, prompt, log, receipt, or third-party artifact. The public web application uses same-origin paths; do not redirect MeaningSystem requests to visitor-localhost or assume that a direct Maenen endpoint accepts a MeaningSystem browser session.

## Public route catalogue and list prices

These are the current repository pricing-manifest values. They are planning metadata until the live manifest and authenticated service confirm them.

| Route ID | Purpose | List price |
|---|---|---:|
| `secure_meaning_run_v1` | Governed intent, integrity, execution and evidence review | 200 MC |
| `align_brief_v1` | Scope, authority, acceptance and verification framing | 60 MC |
| `compare_meaning_v1` | Meaning-level comparison | 130 MC |
| `decision_review_v1` | Decision framing and justification review | 70 MC |
| `evidence_check_v1` | Claim-to-evidence binding | 60 MC |
| `cost_value_review_v1` | Spend, value and quality proportionality | 100 MC |
| `provider_cost_probe_v1` | Provider cost evidence | 100 MC |
| `provider_compare_v1` | Provider comparison under declared criteria | 150 MC |
| `agent_handoff_audit_v1` | Delegation continuity, authority and responsibility | 100 MC |
| `agent_claim_assurance_v1` | Read-only claim and receipt-chain assurance | 90 MC on the qualified successful outcome described below |
| `artifact_trust_review_v1` | Read-only artifact/passport/receipt review | 60 MC on the qualified successful outcome described below |
| `agent_exchange_review_v1` | Read-only exchange and receipt review | 60 MC on the qualified successful outcome described below |
| `transaction_preflight_v1` | Read-only, non-authorising transaction readiness review | 90 MC on the qualified successful outcome described below |
| `preflight_alignment` | Non-executing Preflight Alignment capability | 0 MC |

Before execution, read the current live pricing manifest, check the authenticated account allowance and delegated budget, and retain the returned selected route and observed cost. Stage attribution inside a route bundle is not an additional debit.

## Agent Claim Assurance

`agent_claim_assurance_v1` is a read-only route for assessing an agent claim against a signed receipt and its receipt chain. Its logical stages are:

1. Trust Verify;
2. Trust Proof;
3. Trust Legitimacy.

The route accepts an explicit call through:

```json
{
  "intent": "Assure this agent claim from its signed receipt chain",
  "route_id": "agent_claim_assurance_v1",
  "payload": {
    "agent_claim_assurance": {
      "artifact_hash": "sha256:artifact",
      "receipt": {
        "receipt_id": "r1",
        "issuer_pubkey": "issuer-key",
        "artifact_hash": "sha256:artifact",
        "issued_at": "2026-08-05T12:00:00Z",
        "declared_scope": "agent.execute",
        "signature": "signature"
      },
      "receipt_chain": [
        {
          "receipt_id": "r1",
          "receipt_type": "resolve_v4",
          "status": "success",
          "payload": {
            "summary": "agent result"
          }
        }
      ],
      "expected_intent": "execute the approved task",
      "anchor": null,
      "mode": "strict"
    }
  }
}
```

The receipt chain must contain at least one record, and the supplied receipt must be linked to that chain. `anchor` is optional. `mode` is `strict` or `advisory`.

Suggestion eligibility is intentionally cautious. The request must identify an agent claim and provide signed-receipt or receipt-chain evidence, or explicitly require a higher Proof or Legitimacy stage. At least two signal classes are required. A generic request to “verify this statement” is not enough.

The route preserves executor status separately from its assurance conclusion:

```json
{
  "execution_status": "completed",
  "overall_assurance": "assured"
}
```

A technically completed route can instead conclude `hold` or `rejected`. A technical node failure produces `execution_status="failed"` and `overall_assurance="failed"`. Partial findings and explicit skipped-stage findings remain available in the route result.

## Agent Claim Assurance pricing

An assured, completed `agent_claim_assurance_v1` run costs **90 MC**. The internal stage attribution is Trust Verify 20 MC, Trust Proof 40 MC, and Trust Legitimacy 30 MC; these are not three extra debits on top of the 90 MC bundle.

The route charge is recorded only when both conditions are true:

- `execution_status="completed"`;
- `overall_assurance="assured"`.

Outcomes with `overall_assurance="hold"`, `"rejected"`, or `"failed"` charge **0 MC**. Missing required evidence is rejected before execution and also charges 0 MC.

Before any chargeable call, confirm delegated spending authority and read the current shared pricing manifest. Do not increase a budget, buy credits, or retry an uncertain chargeable operation autonomously.

## Artifact Trust Review

`artifact_trust_review_v1` is a read-only route for checking a submitted canonical JSON artifact and submitted Artifact Passport against non-empty signed receipt evidence. Its stages are:

1. `artifact.passport.verify` — recompute the canonical content hash and derived artifact ID;
2. `artifact.receipt.bind` — check passport fields against the signed receipt attachment and common chain anchor;
3. `trust.verify.proof` — cryptographically verify the supplied receipt history and assess its continuity.

An explicit request uses `route_id="artifact_trust_review_v1"` and this payload shape:

```json
{
  "intent": "Review this artifact passport against its signed receipt history",
  "route_id": "artifact_trust_review_v1",
  "payload": {
    "artifact_trust_review": {
      "content": {"title": "Submitted artifact", "version": 1},
      "passport": {
        "artifact_id": "art_example",
        "content_hash": "example-content-sha256",
        "receipt_chain_hash": "rch_example",
        "issuer": "maenen.ai",
        "created_at": "2026-08-05T12:00:00.000Z",
        "trust_profile_ref": null
      },
      "receipt_chain": [
        {
          "receipt_version": "4.0.0",
          "receipt_id": "rcpt_example",
          "issuer": "maenen.ai",
          "chain_hash": "rch_example",
          "artifact": {
            "artifact_id": "art_example",
            "content_hash": "example-content-sha256",
            "issuer": "maenen.ai",
            "receipt_chain_hash": "rch_example"
          },
          "receipt_hash": "sha256:example",
          "signature": "ed25519:example"
        }
      ],
      "mode": "strict",
      "media_type": "application/json",
      "canonicalization": "maenen.v4.canonical-json"
    }
  }
}
```

The example abbreviates the signed v4 envelope; callers must submit a complete valid receipt. Suggestion is deliberately cautious: an artifact/passport subject, signed receipt-chain or provenance evidence, and an explicit review or verification task must all be present. Suggestion recommends only and cannot run the route without confirmation.

The result keeps technical execution separate from the domain conclusion:

```json
{
  "execution_status": "completed",
  "overall_trust": "verified"
}
```

A completed route may instead conclude `hold` or `rejected`; a technical failure concludes `failed`. All three return retained findings and explicit skipped-stage findings and charge **0 MC**. Only `execution_status="completed"` with `overall_trust="verified"` charges the single **60 MC** route bundle. The 20 MC passport-verification and 40 MC Trust Proof values are attribution, not additional debits; deterministic receipt binding is included at 0 MC.

The route establishes only deterministic artifact identity, submitted-content hash agreement, passport/receipt field consistency, and integrity and continuity of the supplied signed receipt history. It does not establish the passport issuer's agent identity, truth, safety, ownership, Maenen authorship, or fitness for an intended use. It does not create or persist an Artifact Passport and does not use an in-memory passport lookup, Trust Profile, Agent Identity, Trust Legitimacy, or Trust-Transact mutation as evidence.

## Agent Exchange Review

`agent_exchange_review_v1` is a read-only evidential review of a specific submitted exchange. Its stages are `exchange.envelope.verify`, `exchange.payload.bind`, `exchange.receipts.correlate`, and `trust.verify.proof`.

The input supplies an exchange envelope containing `exchange_id`, declared `sender_ref` and `receiver_ref`, sent and received payload hashes, a receipt-chain anchor and optional artifact ID; canonical JSON sent and received payloads; an optional submitted Artifact Passport; a non-empty receipt chain; and `strict` or `advisory` mode. Signed receipt payloads identify the same exchange using an `exchange` block containing the exchange ID, participant references, payload hash, optional artifact ID, and a `sent`, `received`, or `acknowledged` role.

Participant references remain declared identifiers. This route does not establish real-world, operator, legal, or agent identity unless a separate existing Maenen principal/key binding independently establishes it. It does not claim that delivery proves understanding or action, does not assess semantic preservation, and does not establish content truth, safety or suitability.

In advisory mode, correlated signed sending and receiving evidence can verify the exchange while separately reporting that acknowledgement is absent. Strict mode requires acknowledgement evidence. Missing required evidence produces a hold in advisory mode and rejection in strict mode; conflicts are rejected in both modes. Technical failures retain partial findings and produce `execution_status="failed"` with `overall_exchange="failed"`.

Only `execution_status="completed"` with `overall_exchange="verified"` charges one **60 MC** route bundle. Exchange payload/passport binding contributes 20 MC attribution and Trust Proof contributes 40 MC; envelope verification and receipt correlation are included proof layers. Hold, rejected, failed, validation-failure and missing-evidence outcomes charge 0 MC.

Agent Exchange Review does not run or duplicate `agent_handoff_audit_v1`. Use Agent Handoff Audit separately when the question concerns semantic continuity, omissions, changes, responsibility transfer or authority bleed.

## Transaction Preflight

`transaction_preflight_v1` is a public, read-only assessment of a submitted transaction proposal. It validates the proposal and material terms, binds submitted transaction, approval, artifact, passport and exchange references to signed evidence, checks submitted authority scope with Trust Verify, runs Trust Proof once, reuses that chain-bound Proof in Trust Legitimacy, and consolidates a readiness conclusion.

An explicit request uses `route_id="transaction_preflight_v1"`. The versioned `transaction_preflight_input_v1` payload supplies a stable proposal ID, transaction type, declared parties and roles, amount, currency, asset, quantity and material terms, constraints, requested action, purpose and context, exactly one submitted signed authority grant with a signed time-bounded authority-status attestation, required approvals and conditions, optional artifact/passport and exchange references, a non-empty receipt chain, validity times, and strict or advisory mode.

The conclusions are `ready`, `ready_with_cautions`, `hold`, `rejected` and `failed`. `ready_with_cautions` means every mandatory submitted-evidence gate passed and all remaining cautions are explicitly non-blocking. Those cautions remain visible in the result, Trace and receipts.

Only `execution_status="completed"` with `overall_readiness="ready"` or `overall_readiness="ready_with_cautions"` charges one **90 MC** route bundle. Trust Verify contributes 20 MC, Trust Proof 40 MC and Trust Legitimacy 30 MC. Proposal validation, evidence binding and readiness consolidation are included at 0 MC. Hold, rejected, failed, missing-evidence and validation-failure outcomes charge 0 MC. Node attribution is not component-level billing.

The result and every route finding declare `non_authorisation=true` and `non_execution=true`. A route suggestion or confirmation means only “run this assessment”; it is never permission to transact. The route never executes, initiates, authorises, approves, signs, publishes, reserves, commits, settles or records a transaction, and never moves funds or assets. It does not call a mutating Trust-Transact or payment operation.

Participant references remain declared identifiers. The route does not establish legal or real-world identity, ownership, solvency, available funds, custody, legal enforceability, regulatory compliance, commercial wisdom, future performance or guaranteed safety. It does not treat absence of contrary evidence as positive evidence and does not use in-memory state as durable proof.

Use `cost_value_review_v1` as an optional, separately selected follow-up when economic value or proportionality must be assessed. Transaction Preflight does not nest Evidence Check, Decision Review, Cost/Value Review, Agent Claim Assurance, Artifact Trust Review or Agent Exchange Review and does not duplicate their route charges.

Trust Advanced is not part of this route and is not introduced into MeaningSystem.

## Receipts, timeouts, and capsules

Agents should retain the original receipt payload, route ID, request reference, artifact hashes, findings, verification state, and observed cost. A receipt applies only to its named artifacts, route version, and execution context.

A timeout does not prove failure. Before retrying, check for an existing receipt, run status, idempotency record, or usage evidence so the same operation is not charged twice.

Capsules are limited to export, read, inspection, verification and provenance evidence. They do not rerun, replay, restore, rehydrate, resume, branch, fork or merge the original execution.

## Safety boundary

MeaningSystem routes assess and produce evidence. They do not confer permission for downstream action. In particular, `agent_claim_assurance_v1`, `artifact_trust_review_v1`, `agent_exchange_review_v1`, and `transaction_preflight_v1` do not create, update, close, complete, dispute, or otherwise mutate Trust or Trust-Transact records. Agent Exchange Review does not create an exchange, issue a passport, write an acknowledgement, record an outcome, mutate a Trust Profile, or update trust history. Transaction Preflight never calls transaction execution, reservation, settlement, listing creation, verification-record creation or outcome mutation. Any mutating operation requires its own explicit public contract, caller authority, confirmation, and billing decision.

---

## Suite boundaries and cross-references

Maenen Labs supplies the philosophy and portfolio context.[^suite-labs] Maenen.ai documents direct modular tools.[^suite-api] MeaningSystem is the governed route layer described here.[^suite-meaning] CompareThisThat is a separate product, shop and wallet.[^suite-compare] MeetMeaning has separate access and its own beta operating contract.[^suite-meet] AligningNow is a separate human transition product, not a MeaningSystem route.[^suite-align] Direct Maenen schemas and live machine contracts belong to the API host.[^suite-contract]

Do not transfer credentials, entitlements, balances, prices, or deployment claims across these product boundaries unless the current deployed contract explicitly permits it.

[^suite-labs]: [Maenen Labs](https://www.maenenlabs.com/) — philosophy, research identity and portfolio context; it is not an API schema.
[^suite-api]: [Maenen.ai](https://www.maenen.ai/) — modular direct-checkpoint tools for agents and developers.
[^suite-meaning]: [MeaningSystem](https://www.meaningsystem.io/) — governed preset routes, preflight, trace and evidence.
[^suite-compare]: [CompareThisThat](https://www.comparethisthat.com/) — meaning-level document comparison under a separate product and commercial namespace.
[^suite-meet]: [MeetMeaning](https://www.meetmeaning.com/) — evidence-linked meeting intelligence with a separate account-gated boundary.
[^suite-align]: [AligningNow](https://www.aligningnow.com/) — human-facing transition clarification; verify its own current public status before use.
[^suite-contract]: [Maenen API contract host](https://api.maenen.ai/) — published endpoint documentation and live discovery/pricing govern direct calls.

Production runtime OpenAPI is not a public discovery source. Validate the published endpoint documentation and product/machine contract actually served by the intended host before use; this local guide is not proof of public delivery.

## Qualified monthly plan contract

| Plan | GBP/month | Base MC | Bonus MC | Total usable MC | Contracted seats |
|---|---:|---:|---:|---:|---:|
| Individual | £10 | 0 | 0 | 0 | 1 |
| Team | £20 | 27,200 | 6,800 | 34,000 | 5 |
| Enterprise | £99 | 133,333 | 66,667 | 200,000 | 20 |

Totals include the bonus. Monthly base and bonus allocations expire at their billing-period end without rollover; top-ups remain a separate credit class. Additional usage is £0.72 per 1,000 MC. The explanatory $1 USD ≈ £0.74 GBP = 1,000 MC reference is not the GBP settlement quote. Seats are contracted metadata pending account/team implementation; no membership-enforcement claim is made. The existing activation trial remains seven days, five preflights, five runs, one seat and zero included MC. Payment/provider enablement and deployment remain separately gated.

A MeaningSystem-scoped key may call direct `POST /v1/meaning/compare` for 83 MC from the `meaning_system` wallet. A CompareThisThat-scoped API key instead uses its separate Compare credit allowance (Core 1, Review 3); product browser sessions use web uses. Credential scope selects the wallet. Compare-only plans grant no other Maenen/MeaningSystem access. Review has no toolsuite MC tariff. Returned direct Core receipt references include authenticated usage-event linkage; this linkage is separate from the signed reference and does not promise universal execution replay.