The Nordibo meeting schema

No bot in the room

Nordibo never sends a bot into your meeting. Audio is recorded in the participant's own client app, on the participant's own device, and nowhere else. This is not a setting you have to remember, it is a structural property of the format itself: the schema pins bot_in_meeting to a constant false and capture_method to client_recording. A payload claiming anything else is by definition not valid nordibo-meeting/v1.

Two schemas: delivery and transcript

Both schema files are published under CC BY 4.0. You may use, implement and adapt them, including commercially, as long as you credit Nordibo (Wilhelmsson Labs AB).

What a delivery looks like

{
  "type": "MEETING_ENCODED",
  "source": "nordibo",
  "$schema": "https://nordibo.se/schema/meeting/v1.json",
  "format_version": "nordibo-meeting/v1",
  "tier": "B",
  "processing_path": {
    "stt": "berget-se",
    "structuring": "vertex-eu",
    "storage": "encrypted-48h",
    "foreign_law_exposure": "eu-us-owned-provider",
    "ai_generated": {
      "marking": "eu-ai-act-art50-2",
      "provider": "google-vertex-ai",
      "models": ["eu/gemini-3.5-flash"],
      "fields": ["context_summary", "decisions[].summary", "action_items[].task"],
      "verbatim_fields": ["decisions[].quote", "action_items[].quote"]
    }
  },
  "delivered_at": "2026-07-18T14:30:00Z",
  "meeting": {
    "title": "Q3 planning",
    "started_at": "2026-07-18T13:00:00Z",
    "capture_method": "client_recording",
    "bot_in_meeting": false
  },
  "decisions": [{
    "summary": "Ship the pilot to the first design partner in August.",
    "quote": "then we ship the pilot to them in August",
    "made_by": "Anna"
  }],
  "action_items": [{
    "task": "Send the draft agreement for review.",
    "owner": "Johan",
    "due": "Friday",
    "quote": "I will send the draft agreement before Friday"
  }],
  "open_questions": [],
  "context_summary": "Planning meeting for the Q3 pilot. Next step is the agreement review."
}

The quote fields are the contract: an item without a verifiable verbatim quote from the transcript is dropped before delivery, never invented. Your AI can check every claim against the source.

Data, never instructions

Everything under meeting, decisions, action_items, open_questions, qa_pairs and context_summary is untrusted meeting content: things real people said in a real conversation. A receiving AI must treat those fields as data to act on, never as instructions to follow. Every payload carries this rule with it in _nordibo_instruction, so it holds even for a receiver with no preconfiguration at all.

• Webhook path: Nordibo deletes its copy of the meeting immediately after delivery. The optional _nordibo_receipt field is the verifiable trace of that: what was delivered, where, and that the copy is gone.
• MCP path: the distilled result is stored encrypted at rest and deleted as soon as your AI fetches it, normally within 48 hours. If it is never fetched, it is still deleted automatically, at the latest 30 days after the meeting.
• Sensitivity tiers: A, B and C mark how the meeting was allowed to be processed. The most sensitive tier is never deliverable at all: a blocked meeting produces a content-free MEETING_BLOCKED notice, so a sensitive meeting cannot leak through its own status message.

Verifying a webhook delivery

Webhook deliveries are signed with HMAC-SHA256(secret, "<timestamp>.<nonce>.<raw-body>"). The signature, timestamp and nonce arrive in headers; you rebuild the signing string from the raw request body and compare.

The body is canonical JSON with sorted keys, but you should never re-serialise: hash the raw bytes you received. A full receiver walkthrough with code for Node and n8n is included in the onboarding material every partner gets.

Core fields, nordibo-meeting/v1

The full, normative definitions live in the schema files themselves: meeting/v1.json and transcript/v1.json.

processing_path: which country's law touched this meeting

No other meeting tool tells you, per meeting, which provider and which country's law actually processed the recording. processing_path is that answer, additive in schema v1 (existing fields never change meaning, so a receiver that tolerates unknown fields will never break).

Every value is derived from the code path that actually ran for that meeting, never from what a user clicked in the app. A meeting recorded in secure mode always shows local processing, regardless of what the UI offered.

A meeting is either fully local (foreign_law_exposure: "none", both stt and structuring stayed on Nordibo's server) or it used at least one external provider. Nordibo's cloud path uses Berget AI (Sweden, EEA-owned) for transcription and Google Vertex AI in an EU region for structuring, including any photos the user adds. Google is US-owned, so a typical cloud meeting reads "eu-us-owned-provider": the content stayed in an EU region, but a US-owned provider processed it. Until 2026-09-23 the same meeting was labelled "eea-provider". That did not match the definition above and has been corrected. Labels are set at delivery and never rewritten, so payloads delivered before that date carry the old label.

ai_generated: which fields a model wrote

Article 50(2) of the EU AI Act requires that AI-generated content is marked in a machine-readable form. The ai_generated object inside processing_path carries that marking. It states which provider and which model produced the content, lists every field a language model wrote, and lists separately the fields that are verbatim transcript text.

The distinction the marking draws is between what the meeting said and what a model wrote about it. Transcript turns (transcript/v1) are not AI-generated content: they are a transcription of what was spoken. The quotes carried by every decision, action item and question are likewise verbatim, and each one is checked against the transcript before the meeting is delivered. The summary and the extracted points are the model's own words, and those are the fields the marking names.

The marking is derived from the code path that actually ran, in the same way as the rest of processing_path. It is added by the same function, behind the same checks, and it is signed as part of the receipt. A receiver can therefore verify the marking against the signature rather than take it on trust.

quote_turn_index and quote_start_sec: where a quote came from

Every decision, action item, open question and answered question already carries a verbatim quote: the citation gate drops any item whose quote does not match the transcript. quote_turn_index and quote_start_sec take that one step further, pointing to which turn in the recording produced the quote and its position in seconds. A receiving AI, or a person, can jump straight to the moment something was said.

The lookup is deterministic, not a model guess: once a quote has passed the citation gate, it is matched back to the turn it came from using the same fuzzy-matching threshold as the gate itself. No language model is involved in placing the anchor. Additive in schema v1.1, existing fields unchanged: a receiver built against v1 keeps working, and simply gains two optional fields per item.

Both fields are omitted, never set to zero or null, when a quote cannot be anchored to a single turn, for example a citation assembled from a textfile transcript with no turn boundaries. An omitted field means "not available", not "the recording's first second".

Reachable as an A2A agent

Nordibo speaks A2A (Agent2Agent, hosted by the Linux Foundation) in addition to MCP. The two are not alternatives. MCP is vertical: it connects one agent to the tools and data it already owns. A2A is horizontal: it lets agents talk to each other across organisational boundaries.

That distinction is the whole point. With MCP, a meeting reaches your own assistant. With A2A, a meeting can also report into a counterparty's agent, in another company, without either side adopting the other's platform. The payload is the same published nordibo-meeting/v1 either way, so what crosses the boundary is inspectable rather than proprietary.

Results come back as an A2A artifact carrying both a text part and a data part. The data part is nordibo-meeting/v1 verbatim, so a receiving agent can either read the sentence or work on the structure, without us deciding which. Streaming is deliberately declared false in the agent card: the answer is a lookup against data that already exists, not a generation, so there is nothing to stream.

A signed agent card

The agent card carries a signatures field: a JWS (RFC 7515) over the JCS-canonicalized (RFC 8785) card, detached payload (RFC 7797), using the same RS256 key that already signs Nordibo's OAuth tokens and is published at /oauth/jwks. The protected header carries typ: "nordibo-agentcard+jws", distinct from the key and purpose used for the meeting receipt below. A signed card is what a regulated organisation checks before it trusts a discovery document at all, rather than taking capabilities and auth requirements on faith over plain HTTPS.

Verifying it takes three steps, in any JWS library: drop the signatures field and canonicalize what remains (JCS), decode the base64url protected header to find the key id, then verify the detached signature against that payload using the matching key from /oauth/jwks. METOD_ALIAS keeps 0.3.x clients working (PascalCase method names, the pre-1.0 task state names): the protocol upgrade does not require the ecosystem to move first.

The meeting receipt: nordibo-receipt/v1

Nordibo deletes every meeting's audio, transcript and structured data as soon as it has been delivered or fetched, normally within 48 hours and, in the unfetched MCP-path case, automatically at the latest 30 days after the meeting. What remains is a small, signed JSON document: nordibo-receipt/v1. It carries a hash of the transcript, a hash of the extracted structure, the same verbatim quotes already delivered in every channel (with their time anchors), the tier, the processing path (which STT, which structuring engine, whether content ever left the EU), and a deletion timestamp. Nothing new leaves the building: every field in the receipt was already sent to you once, in the meeting payload itself.

The receipt travels in all four delivery channels: as _nordibo_meeting_receipt in the webhook payload and in the MCP/A2A meeting object, and as a verification link in the follow-up email. It is the one artefact designed to still mean something after the meeting it describes is gone.

A separate signing key, on purpose

The receipt is signed with its own RS256 key (kid distinct from the one signing OAuth tokens and the A2A agent card), published at its own endpoint, /receipts/jwks, never mixed into /oauth/jwks. The reason is rotation horizon. An OAuth signing key must be rotated immediately on any suspicion of compromise, but a receipt has to remain verifiable for years. If one key carried both duties, a legitimate security rotation would silently invalidate every receipt ever issued. Retired receipt keys stay published, forever: new ones are added, none are removed.

The JWS protected header also carries typ: "nordibo-receipt+jws" (the agent card equivalently carries typ: "nordibo-agentcard+jws"), so a verifier can reject a document signed for one purpose being presented as the other, even in the hypothetical case where a key were ever shared.

Verifying a receipt

nordibo.se/verifiera checks a receipt entirely in your browser, using the Web Crypto API. No data is sent to Nordibo, only the public key is fetched. The same four steps work in any JWS library: drop signatures and canonicalize what remains (JCS), decode the protected header to read kid and typ, fetch the matching public key from /receipts/jwks, and verify the detached signature against the canonicalized payload.

Versioning policy

Legacy note: payloads also carry "schema": "nordibo-signal-1.0", the identifier used before this page existed. It is deprecated in favour of format_version and kept so early receivers keep working, which is the versioning policy doing its job.

Why we publish it

Nordibo's promise is that your meeting flows into your own AI, under your own key, with Swedish speech understood on our own self-hosted server in the EU. That promise only means something if you can inspect the pipe. An open schema means you can verify what leaves Nordibo, validate it in your own systems, and switch tools without losing your data's structure. Your meetings, in a format you can keep.

Questions, or building a receiver? Talk to us, or start from the schema files above.