AI Disclosure Notice (EU AI Act Art. 50)

Article 50(1) of the EU AI Act requires that people interacting with an AI system are told so. When an agent’s Transparency settings turn the disclosure on, the Swarmd relay attaches a notice to the reply on every person-facing leg — platform chat, Teams, and your channel. The relay cannot draw your channel’s UI, so showing the notice is the one thing your integration has to do.

If your channel only renders the agent’s reply text, the person never sees the notice and the disclosure is not met. Every channel integration should handle it — it is two lines with the channel client.

Where the notice is configured

In the Swarmd dashboard open the agent → Governance → Transparency (Art. 50):

Setting	Effect on your channel
Disclosure on/off	Whether the relay attaches a notice at all
When: Once, at the first reply of a conversation	The notice arrives with the first reply of each conversation (`contextId`) and never again
When: Every reply	The notice arrives with every reply
Scope	Every channel and human conversation, or only selected channels
Text	The exact sentence the relay sends — show it as-is

The same settings can be set through the API with PUT /registry/v1/agents/{agentId}/governance/transparency.

Which agent’s settings apply

The notice comes from the agent your channel talks to directly — the first hop after the channel. When that agent delegates to other agents, those hops are agent-to-agent, not person-facing, and their transparency settings play no part: a sub-agent’s disclosure never bubbles up, and the front agent’s disclosure is not affected by what sits behind it.

Disclosure enabled on…	What the person sees
The agent the channel is subscribed to	The notice, with that agent’s text and mode
Only a sub-agent it delegates to	Nothing
Both	The notice once, from the front agent’s text only

This follows Art. 50(1): the obligation attaches to the system the person is interacting with, and its owner configures the text and the mode. It also means a person-facing agent with disclosure off stays silent no matter what its sub-agents declare — check the front agent’s Transparency settings, not the chain’s. The channel scope (selected channels) is evaluated against your channel on that same first hop. Synthetic content marking (Art. 50(2)) is different: it applies on every hop, so a sub-agent’s marking still reaches you.

What the relay sends

The notice is never merged into the agent’s reply. It travels beside it, so extractReply() (or status.message) stays the agent’s own words and you can render the two as separate elements:

{
  "aggregateState": "COMPLETED",
  "latestTask": {
    "id": "task-weather",
    "status": {
      "state": "completed",
      "message": { "role": "agent", "parts": [{ "kind": "text", "text": "The weather in Bangkok is rainy, 18:00." }] }
    },
    "metadata": {
      "ai_disclosure": {
        "message_id": "ai-disclosure-7c1e…",
        "article": "Art. 50(1)",
        "text": "You are talking to an AI assistant. Its answers are generated automatically; a person can be asked to review any decision it takes."
      }
    }
  },
  "messages": [
    { "messageId": "7c1e…", "role": "user", "parts": [{ "kind": "text", "text": "What's the weather in Bangkok?" }] },
    { "messageId": "ai-disclosure-7c1e…", "role": "agent", "metadata": { "ai_disclosure": true, "article": "Art. 50(1)" },
      "parts": [{ "kind": "text", "text": "You are talking to an AI assistant. …" }] },
    { "messageId": "m-agent-1", "role": "agent", "parts": [{ "kind": "text", "text": "The weather in Bangkok is rainy, 18:00." }] }
  ]
}

latestTask.metadata.ai_disclosure — present only on turns that carry a notice. This is what you render live.
messages[] — the conversation history. The notice is stored once, before the reply it introduces, flagged with metadata.ai_disclosure: true. This is what you render when a person reopens a conversation.
The channel JSON-RPC endpoint (/relay/v1/channels/{channelId}/agents/{agentId}/a2a/0.3.0) carries the same metadata.ai_disclosure on the result, with the notice message in result.history[].

With the channel client

One message per turn (Slack, SMS, email, simple widgets)

extractReplyWithDisclosure returns one string — the notice first, then the agent’s words — or just the reply when no notice was sent:

import { extractReplyWithDisclosure } from '@swarmd.ai/channel-client';

const state = await swarmd.startAndSend(agentId, text);
await postToChannel(extractReplyWithDisclosure(state));
// "You are talking to an AI assistant. …
//
//  The weather in Bangkok is rainy, 18:00."

Pass { separator } to change what sits between the two (default: a blank line).

Notice as its own element (chat widgets, web UIs)

The completed event carries disclosure next to reply; both land on the same event, so render them in the same pass — the person is told they are talking to an AI as they read its answer:

await swarmd.startAndSend(agentId, text, {
  onEvent: event => {
    if (event.type !== 'completed') return;
    if (event.disclosure) {
      addBubble({ kind: 'notice', label: event.disclosure.article, text: event.disclosure.text });
    }
    addBubble({ kind: 'agent', text: event.reply });
  },
});

extractDisclosure(state) returns the same { text, messageId?, article? } from any ConversationState.

Reopening a conversation

When you rebuild a thread from state.messages (or GET …/conversations/{contextId}/messages), render messages whose metadata.ai_disclosure === true as the notice element and everything else as normal turns. Because the stored notice keeps the same messageId as disclosure.messageId, a live turn and a reload produce the same thread.

A complete, running example is the PrismForce demo in the Swarmd repository (ui/demo-prismforce): src/lib/swarmdRelay.ts wraps the channel client for five channels and src/components/ChatWidget.tsx renders the notice as its own bubble before the reply, including when the reply is released from a human review.

Without the channel client

If you call the conversation REST API directly, read the same two fields:

const state = await relay.sendMessage(contextId, message); // POST …/conversations/{contextId}/messages
const disclosure = state.latestTask?.metadata?.ai_disclosure?.text;
const reply = firstTextPart(state.latestTask?.status?.message) ?? firstArtifactText(state.latestTask);

render(disclosure ? [{ notice: disclosure }, { agent: reply }] : [{ agent: reply }]);

When the relay hands back 202 with aggregateState: WORKING, keep polling GET …/conversations/{contextId}/state; the notice appears on the state that goes COMPLETED, together with the reply.

Checklist

Show the notice before the reply, in the same render — not on the next poll, not behind a click.
Show the relay’s text unchanged; the wording is part of the tenant’s compliance record and is what the audit trail logs.
Show it once per conversation in the default mode: don’t repeat it on later turns, and don’t drop it when the person reopens the thread.
Keep reply for the agent’s words. If your channel has a single text slot, use extractReplyWithDisclosure.

Python

Build your agent

Migrating an existing agent

Python reference

TypeScript

AI Disclosure Notice

AI Disclosure Notice (EU AI Act Art. 50)

Where the notice is configured

Which agent’s settings apply

What the relay sends

With the channel client

One message per turn (Slack, SMS, email, simple widgets)

Notice as its own element (chat widgets, web UIs)

Reopening a conversation

Without the channel client

Checklist

​AI Disclosure Notice (EU AI Act Art. 50)

​Where the notice is configured

​Which agent’s settings apply

​What the relay sends

​With the channel client

​One message per turn (Slack, SMS, email, simple widgets)

​Notice as its own element (chat widgets, web UIs)

​Reopening a conversation

​Without the channel client

​Checklist

AI Disclosure Notice (EU AI Act Art. 50)

Where the notice is configured

Which agent’s settings apply

What the relay sends

With the channel client

One message per turn (Slack, SMS, email, simple widgets)

Notice as its own element (chat widgets, web UIs)

Reopening a conversation

Without the channel client

Checklist