Mnemom Transparency API

Append-only public log of every canonical card identity ever composed. Signed Merkle root + per-row inclusion proofs (cards-as-primitive Phase 5).

GitHub OpenAPI

Operations 5

GET /transparency/consistency Consistency proof that the log grew by append only #
GET /transparency/log/{agent_id} Point-in-time canonical posture lookup #
GET /transparency/log/{agent_id}/recent Recent transparency-log entries for an agent #
GET /transparency/log/{agent_id}/{log_index} Direct log entry by index, with Merkle inclusion proof #
GET /transparency/root Signed current Merkle root for the canonical-card transparency log #

Work with this as data

Every API here is available over the APIs.io API and to AI agents over MCP.

MCP server

One button, every client — Claude, Cursor, VS Code and the rest.

https://apis.io/mcp

Tools for apis

7 MCP tools reach this
  • find_apisBrowse and filter every API in the catalog.
  • get_api_artifactsOne API's artifacts, grouped by type.
  • get_openapiThe primary OpenAPI for this API.
  • find_similar_apisAPIs that look like this one.
  • apis_io_searchSTART HERE — APIs, providers and tags for one query, each with its total.
  • resolveTurn a domain, URL or GitHub org into the provider it belongs to.
  • find_cohortsEvery scored population of providers in the catalog.
All 92 tools →

Call it yourself

curl for this page
This API
curl "https://apis.io/api/v1/apis/mnemom-ai:mnemom-ai-transparency-api"
All apis
curl "https://apis.io/api/v1/apis?limit=25"

Calls without X-API-Key need no key. Calls with it need a paid plan — get a key.

Get an API key

Free tier, no form to fill in. Signing in shares your email address with us — we store it to create your key and to recognise you if you sign in with another provider. By signing up you are subscribing to the APIs.io and API Evangelist newsletters — you can unsubscribe from any issue. See our Privacy Policy and Terms.

A second provider on the same verified email joins the account you already have.

OpenAPI Specification

mnemom-ai-transparency-api-openapi.yml Raw ↑
openapi: 3.2.0
info:
  title: Mnemom Transparency API
  description: Trust infrastructure for AI agents. Transparent alignment verification, behavioral drift detection, and accountability primitives.
  version: 1.0.0
  contact:
    name: Mnemom
    url: https://mnemom.ai
    email: support@mnemom.ai
  license:
    name: Apache 2.0
    url: https://www.apache.org/licenses/LICENSE-2.0
servers:
- url: https://api.mnemom.ai/v1
  description: Production
security:
- BearerAuth: []
- ApiKeyAuth: []
tags:
- name: Transparency
  description: Append-only public log of every canonical card identity ever composed. Signed Merkle root + per-row inclusion proofs (cards-as-primitive Phase 5).
paths:
  /transparency/consistency:
    get:
      operationId: getTransparencyConsistencyProof
      security: []
      summary: Consistency proof that the log grew by append only
      description: 'Returns an RFC 6962 / RFC 9162 §2.1.4 consistency proof that the tree of size `second` contains the tree of size `first` as a prefix — i.e. the first `first` entries were not reordered, altered, or removed. `second` defaults to the log''s current size.


        This is the only endpoint that can distinguish "the log grew" from "the log was rewritten and re-signed": an inclusion proof verifies against whatever root it is given, so it cannot detect a wholesale reissue. Chain these proofs across successive signed roots from `GET /v1/transparency/root` and the append-only claim becomes checkable rather than promised.


        What it does NOT prove: that Mnemom published every root it computed. A consistent chain of roots shown to you could coexist with a different, internally-consistent chain shown to somebody else (a "split view"). Detecting that requires gossip between independent monitors. MNE-6384.'
      tags:
      - Transparency
      parameters:
      - name: first
        in: query
        required: true
        schema:
          type: integer
          minimum: 1
        description: The earlier tree_size — typically one you already hold a signed root for.
      - name: second
        in: query
        required: false
        schema:
          type: integer
          minimum: 1
        description: The later tree_size. Defaults to the log's current size. Must be >= `first`; a request where it is smaller is rejected rather than answered, because a shrinking log is itself the finding.
      responses:
        '200':
          description: Consistency proof between the two tree sizes.
          content:
            application/json:
              schema:
                type: object
                required:
                - construction
                - first
                - second
                - first_root
                - second_root
                - hashes
                properties:
                  construction:
                    type: string
                    const: mnemom.transparency.rfc6962/v1
                    description: Named construction the proof is built against. Versioned wire string — a new construction mints a new identity rather than editing this one, so a verifier can never silently apply the wrong rules.
                  first:
                    type: integer
                    minimum: 1
                    description: The earlier tree_size.
                  second:
                    type: integer
                    minimum: 1
                    description: The later tree_size.
                  first_root:
                    type: string
                    pattern: ^[0-9a-f]{64}$
                    description: Merkle root at tree_size = first. Compare this against the signed root you already hold for that size — if it differs, the log was rewritten.
                  second_root:
                    type: string
                    pattern: ^[0-9a-f]{64}$
                    description: Merkle root at tree_size = second.
                  hashes:
                    type: array
                    items:
                      type: string
                      pattern: ^[0-9a-f]{64}$
                    description: RFC 6962 §2.1.2 consistency path, in the order the §2.1.4.2 verification algorithm consumes it. Empty ONLY when first === second (nothing was appended). Note that when `first` is an exact power of two the generator omits MTH(D[0:first]) because the verifier re-derives it from first_root.
        '400':
          $ref: '#/components/responses/BadRequest'
        '404':
          description: 'The log is empty, or one of the requested sizes exceeds the log''s current size. The latter is worth investigating: if you hold a signed root for a larger size than the log now reports, the log shrank.'
          content:
            application/json:
              schema:
                $ref: '#/components/schemas/Error'
        '429':
          $ref: '#/components/responses/TooManyRequests'
        '500':
          $ref: '#/components/responses/InternalServerError'
        '503':
          $ref: '#/components/responses/ServiceUnavailable'
  /transparency/log/{agent_id}:
    get:
      operationId: getTransparencyLogEntryAt
      security: []
      summary: Point-in-time canonical posture lookup
      description: Returns the transparency-log row whose `composed_at` is the greatest at-or-before the `at` query parameter, plus a freshly-computed Merkle inclusion proof. `card_kind` defaults to `alignment`. cards-as-primitive Phase 5 A2.
      tags:
      - Transparency
      parameters:
      - name: agent_id
        in: path
        required: true
        schema:
          type: string
      - name: at
        in: query
        required: true
        schema:
          type: string
          format: date-time
        description: ISO-8601 UTC timestamp.
      - name: card_kind
        in: query
        required: false
        schema:
          type: string
          enum:
          - alignment
          - protection
        description: Defaults to `alignment`.
      responses:
        '200':
          description: Log entry + inclusion proof.
          content:
            application/json:
              schema:
                type: object
                required:
                - entry
                - inclusion_proof
                properties:
                  entry:
                    type: object
                    required:
                    - log_index
                    - agent_id
                    - card_kind
                    - content_hash
                    - version
                    - composed_at
                    - signed_attestation
                    - signing_key_id
                    - merkle_leaf_hash
                    - tree_size_after
                    - integrated_time
                    properties:
                      log_index:
                        type: integer
                        minimum: 1
                      agent_id:
                        type: string
                      card_kind:
                        type: string
                        enum:
                        - alignment
                        - protection
                      content_hash:
                        type: string
                        pattern: ^sha256:[0-9a-f]{64}$
                      version:
                        type: integer
                        minimum: 1
                      composed_at:
                        type: string
                        format: date-time
                      signed_attestation:
                        type: string
                        description: JWS Compact serialization signed by Mnemom over the canonical identity tuple.
                      signing_key_id:
                        type: string
                      merkle_leaf_hash:
                        type: string
                        pattern: ^[0-9a-f]{64}$
                      tree_size_after:
                        type: integer
                        minimum: 1
                      integrated_time:
                        type: string
                        format: date-time
                  inclusion_proof:
                    type: object
                    required:
                    - leaf_hash
                    - log_index
                    - tree_size
                    - hashes
                    properties:
                      leaf_hash:
                        type: string
                        pattern: ^[0-9a-f]{64}$
                      log_index:
                        type: integer
                        minimum: 1
                      tree_size:
                        type: integer
                        minimum: 1
                      hashes:
                        type: array
                        items:
                          type: object
                          required:
                          - sibling
                          - position
                          properties:
                            sibling:
                              type: string
                              pattern: ^[0-9a-f]{64}$
                            position:
                              type: string
                              enum:
                              - left
                              - right
        '400':
          $ref: '#/components/responses/BadRequest'
        '404':
          $ref: '#/components/responses/NotFound'
        '429':
          $ref: '#/components/responses/TooManyRequests'
        '500':
          $ref: '#/components/responses/InternalServerError'
        '503':
          $ref: '#/components/responses/ServiceUnavailable'
  /transparency/log/{agent_id}/recent:
    get:
      operationId: getTransparencyRecentEntries
      security: []
      summary: Recent transparency-log entries for an agent
      description: 'Returns the last N transparency-log entries for the agent, newest first (`log_index.desc`), each with a freshly-computed Merkle inclusion proof. Public + unauthenticated like its siblings; the per-agent filter is the leak defense (data scoping, not org authz). Bounded by a server-clamped `limit` (default 10, max 100). `card_kind` defaults to `alignment`. An agent with no attestations returns `200 { data: [] }`. cards-as-primitive Phase 5 A2.'
      tags:
      - Transparency
      parameters:
      - name: agent_id
        in: path
        required: true
        schema:
          type: string
      - name: limit
        in: query
        required: false
        schema:
          type: integer
          minimum: 1
          maximum: 100
          default: 10
        description: Max entries to return; clamped server-side to 100.
      - name: card_kind
        in: query
        required: false
        schema:
          type: string
          enum:
          - alignment
          - protection
        description: Defaults to `alignment`.
      responses:
        '200':
          description: Recent log entries + inclusion proofs (newest first).
          content:
            application/json:
              schema:
                type: object
                required:
                - data
                properties:
                  data:
                    type: array
                    items:
                      type: object
                      required:
                      - entry
                      - inclusion_proof
                      properties:
                        entry:
                          type: object
                          required:
                          - log_index
                          - agent_id
                          - card_kind
                          - content_hash
                          - version
                          - composed_at
                          - signed_attestation
                          - signing_key_id
                          - merkle_leaf_hash
                          - tree_size_after
                          - integrated_time
                          properties:
                            log_index:
                              type: integer
                              minimum: 1
                            agent_id:
                              type: string
                            card_kind:
                              type: string
                              enum:
                              - alignment
                              - protection
                            content_hash:
                              type: string
                              pattern: ^sha256:[0-9a-f]{64}$
                            version:
                              type: integer
                              minimum: 1
                            composed_at:
                              type: string
                              format: date-time
                            signed_attestation:
                              type: string
                              description: JWS Compact serialization signed by Mnemom over the canonical identity tuple.
                            signing_key_id:
                              type: string
                            merkle_leaf_hash:
                              type: string
                              pattern: ^[0-9a-f]{64}$
                            tree_size_after:
                              type: integer
                              minimum: 1
                            integrated_time:
                              type: string
                              format: date-time
                        inclusion_proof:
                          type: object
                          required:
                          - leaf_hash
                          - log_index
                          - tree_size
                          - hashes
                          properties:
                            leaf_hash:
                              type: string
                              pattern: ^[0-9a-f]{64}$
                            log_index:
                              type: integer
                              minimum: 1
                            tree_size:
                              type: integer
                              minimum: 1
                            hashes:
                              type: array
                              items:
                                type: object
                                required:
                                - sibling
                                - position
                                properties:
                                  sibling:
                                    type: string
                                    pattern: ^[0-9a-f]{64}$
                                  position:
                                    type: string
                                    enum:
                                    - left
                                    - right
        '400':
          $ref: '#/components/responses/BadRequest'
        '404':
          $ref: '#/components/responses/NotFound'
        '429':
          $ref: '#/components/responses/TooManyRequests'
        '500':
          $ref: '#/components/responses/InternalServerError'
        '503':
          $ref: '#/components/responses/ServiceUnavailable'
  /transparency/log/{agent_id}/{log_index}:
    get:
      operationId: getTransparencyLogEntryByIndex
      security: []
      summary: Direct log entry by index, with Merkle inclusion proof
      description: Returns the row at `log_index` (if it belongs to `agent_id`) plus a freshly-computed inclusion proof. cards-as-primitive Phase 5 A2.
      tags:
      - Transparency
      parameters:
      - name: agent_id
        in: path
        required: true
        schema:
          type: string
      - name: log_index
        in: path
        required: true
        schema:
          type: integer
          minimum: 1
      responses:
        '200':
          description: Log entry + inclusion proof.
          content:
            application/json:
              schema:
                type: object
                required:
                - entry
                - inclusion_proof
                properties:
                  entry:
                    type: object
                    required:
                    - log_index
                    - agent_id
                    - card_kind
                    - content_hash
                    - version
                    - composed_at
                    - signed_attestation
                    - signing_key_id
                    - merkle_leaf_hash
                    - tree_size_after
                    - integrated_time
                    properties:
                      log_index:
                        type: integer
                        minimum: 1
                      agent_id:
                        type: string
                      card_kind:
                        type: string
                        enum:
                        - alignment
                        - protection
                      content_hash:
                        type: string
                        pattern: ^sha256:[0-9a-f]{64}$
                      version:
                        type: integer
                        minimum: 1
                      composed_at:
                        type: string
                        format: date-time
                      signed_attestation:
                        type: string
                        description: JWS Compact serialization signed by Mnemom over the canonical identity tuple.
                      signing_key_id:
                        type: string
                      merkle_leaf_hash:
                        type: string
                        pattern: ^[0-9a-f]{64}$
                      tree_size_after:
                        type: integer
                        minimum: 1
                      integrated_time:
                        type: string
                        format: date-time
                  inclusion_proof:
                    type: object
                    required:
                    - leaf_hash
                    - log_index
                    - tree_size
                    - hashes
                    properties:
                      leaf_hash:
                        type: string
                        pattern: ^[0-9a-f]{64}$
                      log_index:
                        type: integer
                        minimum: 1
                      tree_size:
                        type: integer
                        minimum: 1
                      hashes:
                        type: array
                        items:
                          type: object
                          required:
                          - sibling
                          - position
                          properties:
                            sibling:
                              type: string
                              pattern: ^[0-9a-f]{64}$
                            position:
                              type: string
                              enum:
                              - left
                              - right
        '400':
          $ref: '#/components/responses/BadRequest'
        '404':
          $ref: '#/components/responses/NotFound'
        '429':
          $ref: '#/components/responses/TooManyRequests'
        '500':
          $ref: '#/components/responses/InternalServerError'
        '503':
          $ref: '#/components/responses/ServiceUnavailable'
  /transparency/root:
    get:
      operationId: getTransparencyRoot
      security: []
      summary: Signed current Merkle root for the canonical-card transparency log
      description: Returns the current root + tree_size + published_at, signed by the active AAP signing key. Distinct `typ` from per-card attestations (`AAP-TransparencyRoot/v1`). Cacheable for 30 seconds; consumers refresh when they want a fresh root. cards-as-primitive Phase 5 A2.
      tags:
      - Transparency
      responses:
        '200':
          description: Signed root, or an empty-state payload when the log has no entries.
          content:
            application/json:
              schema:
                oneOf:
                - type: object
                  required:
                  - typ
                  - tree_size
                  - root_hash
                  - published_at
                  - signing_key_id
                  - signature
                  properties:
                    typ:
                      type: string
                      const: AAP-TransparencyRoot/v1
                      description: Domain separator distinguishing a signed root from a per-card attestation.
                    tree_size:
                      type: integer
                      minimum: 0
                    root_hash:
                      type: string
                      pattern: ^[0-9a-f]{64}$
                    published_at:
                      type: string
                      format: date-time
                    signing_key_id:
                      type: string
                    signature:
                      type: string
                      description: Base64url Ed25519 signature over canonical_json(commitment), where commitment is this object MINUS `signature` — i.e. {typ, tree_size, root_hash, published_at, signing_key_id}. Verify by dropping `signature`, canonicalising the rest (sorted keys, no whitespace), and checking against the JWKS key for signing_key_id.
                - type: object
                  required:
                  - tree_size
                  properties:
                    tree_size:
                      const: 0
                    message:
                      type: string
        '429':
          $ref: '#/components/responses/TooManyRequests'
        '500':
          $ref: '#/components/responses/InternalServerError'
        '503':
          $ref: '#/components/responses/ServiceUnavailable'
components:
  responses:
    ServiceUnavailable:
      description: An upstream dependency is currently unavailable. The request was not processed; retry after the cooldown window.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
    InternalServerError:
      description: Server error — request was well-formed but the server failed to fulfill it. Typically a downstream dependency (DB / RPC / external API) returned an unexpected error.
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
    TooManyRequests:
      description: Rate-limit exceeded. The global per-IP limiter (100 requests/minute, applied to every `/v1/*` route) rejected this request. Back off until the window resets — `Retry-After` carries the cooldown in seconds and `X-RateLimit-Reset` the absolute reset time.
      headers:
        Retry-After:
          description: Seconds to wait before retrying.
          schema:
            type: integer
            minimum: 1
        X-RateLimit-Limit:
          description: Requests permitted per window.
          schema:
            type: integer
        X-RateLimit-Remaining:
          description: Requests remaining in the current window (0 on a 429).
          schema:
            type: integer
            minimum: 0
        X-RateLimit-Reset:
          description: Unix epoch seconds at which the current window resets.
          schema:
            type: integer
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
    BadRequest:
      description: Bad request
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
    NotFound:
      description: Resource not found
      content:
        application/json:
          schema:
            $ref: '#/components/schemas/Error'
  schemas:
    Error:
      type: object
      description: Canonical error envelope (ADR-API-001 conv 1). `error` is always an object — never a bare string. Every 4xx/5xx response across the API conforms to this shape; the runtime helper is `src/http-errors.ts::buildErrorBody`.
      required:
      - error
      properties:
        error:
          type: object
          required:
          - code
          - message
          properties:
            code:
              type: string
              pattern: ^[a-z][a-z0-9_]*$
              description: 'Stable, machine-matchable failure identifier (lowercase snake_case). Clients may branch on this; the string is part of the contract.


                **Status-class defaults** — emitted when no caller code is supplied (`errorCodeForStatus(status)`): `bad_request` (400), `unauthorized` (401), `forbidden` (403), `not_found` (404), `method_not_allowed` (405), `conflict` (409), `gone` (410), `precondition_failed` (412), `payload_too_large` (413), `unsupported_media_type` (415), `unprocessable_entity` (422), `precondition_required` (428), `rate_limited` (429), `internal_error` (500), `not_implemented` (501), `bad_gateway` (502), `service_unavailable` (503), `gateway_timeout` (504). Fallback `error` for unmapped statuses.


                **Caller-supplied codes** — handlers may pass an explicit `code` for a specific failure class. Examples: `agent_not_found`, `invalid_hash_proof`, `already_linked`, `idempotency_conflict`, `feature_gated`, `schema_validation_failed`, `no_token`, `bad_canonical_payload`.


                **Care-framed sub-resource codes** — the cards-as-primitive surface passes its stable care code-string straight through as `error.code`. Examples: `if_match_absent`, `if_match_stale`, `if_match_malformed`, `primitive_validation_failed`.'
            message:
              type: string
              description: Human-readable, care-framed explanation of the failure.
            details:
              description: 'Optional structured context for the failure (any JSON value: object, array, or primitive). Common shapes: validation findings list, idempotency-conflict diff, `{presented_etag, current_etag}` on a stale `If-Match`, etc. Mirrors the helper''s `details?: unknown`.'
  securitySchemes:
    BearerAuth:
      type: http
      scheme: bearer
      bearerFormat: JWT
      description: 'Supabase JWT token in Authorization: Bearer header'
    ApiKeyAuth:
      type: apiKey
      in: header
      name: X-Mnemom-Api-Key
      description: Mnemom API key (mnm_... format)
    ServiceRole:
      type: http
      scheme: bearer
      bearerFormat: JWT
      description: Supabase service role bearer JWT. Used by /blog admin operations that talk directly to Supabase. NOT used by /internal/* or /v1/arena/internal/* — those use the custom-header schemes below.
    InternalKeyAuth:
      type: apiKey
      in: header
      name: X-Internal-Key
      description: Internal service-to-service shared secret, timing-safe compared against INTERNAL_API_KEY. Used by /internal/* gateway routes (compose, agents, webhooks emit).
    ServiceKeyAuth:
      type: apiKey
      in: header
      name: X-Service-Key
      description: Service-to-service shared secret, timing-safe compared against MNEMOM_SERVICE_KEY. Used by /v1/arena/internal/*, /v1/on-chain/*, and the /v1/internal/* readers consumed by the reputation cron.
    CoherenceTokenAuth:
      type: http
      scheme: bearer
      description: Per-cell coherence bearer token. Provisioned in 1Password vault `mnemom-coherence` (one item per receiver). Value compared against COHERENCE_<NAME>_SERVICE_TOKEN_EXPECTED. Used by /v1/internal/coherence/* and /v1/internal/governance/dispatch.
    ArenaCandidateTokenAuth:
      type: http
      scheme: bearer
      description: Dedicated arena writer token (ADR-004 §"Arena dedicated writer token"). Compared against ARENA_RECIPE_CANDIDATE_TOKEN. The token's only capability is writing recipe candidates with writer_identity='arena-bypass' (stamped server-side). Used by POST /v1/internal/recipe-candidates.
    CustomerVoiceTokenAuth:
      type: http
      scheme: bearer
      description: Customer Voice API bearer token. Timing-safe compared against CUSTOMER_VOICE_API_TOKEN. Grants access to all /v1/internal/feedback/* endpoints (MNE-1876). No customer-facing or reporter-read capability.
    CookieAuth:
      type: apiKey
      in: cookie
      name: mnemom_session
      description: 'HttpOnly, Secure, SameSite=Lax cookie issued by /v1/auth/sign-in (or the SSO / email-callback flows). The value is an AES-256-GCM-encrypted blob of {access_token, refresh_token, issued_at, auth_method}. Browser clients include this automatically with `credentials: "include"`.'
    LicenseJwtAuth:
      type: http
      scheme: bearer
      bearerFormat: JWT
      description: License JWT (HS256, HMAC-signed with LICENSE_SIGNING_SECRET). Used by self-hosted deployment instances to authenticate `/v1/deployments/heartbeat`. Not interchangeable with the Supabase user JWT.
    AgentAuth:
      type: apiKey
      in: header
      name: X-Mnemom-Agent-Proof
      description: 'Agent possession proof: the full SHA-256 hex digest of `${apiKey}|${agentName}` (or `${apiKey}` for an unnamed singleton agent) — the same `hash_proof` primitive used by POST /v1/agents claim, link-agent, and verify-binding. The server resolves the agent by `agent_hash = proof[:16]`. The agent''s *own* identity (ADR-API-001 third auth class) — distinct from ApiKeyAuth (`X-Mnemom-Api-Key`, which resolves a user/account, not an agent).'