Two patterns for multi-agent attestation. CrewAI witnesses task orchestration. A2A Protocol witnesses inter-agent messaging. Both produce verifiable chain evidence.
Who this is for: Multi-agent system builders, agentic workflow architects, compliance teams evaluating multi-agent governance, and security engineers implementing accountability across agent boundaries.
Available in SWT3 v0.5.5. CrewAI adapter wraps kickoff() with agent/task topology capture. A2A adapter wraps send() and handleMessage() with bidirectional witnessing. Python and TypeScript. Zero framework dependencies.
Multi-agent systems follow two distinct coordination patterns. Each requires different witnessing strategies:
| Aspect | CrewAI (Orchestration) | A2A Protocol (Messaging) |
|---|---|---|
| Pattern | A central crew coordinates multiple agents working on decomposed tasks | Independent agents send messages to each other directly |
| Entry point | kickoff() launches the full crew workflow | send() delivers a message; handleMessage() receives one |
| Topology | Hierarchical: crew owns agents, agents own tasks | Mesh: any agent can message any other agent |
| Primary evidence | AI-INF.1 (crew execution) + agent/task counts | AI-TOOL.1 (outbound) + AI-ACC.1 (inbound) per message |
| Chain evidence | AI-CHAIN.1 (implicit via topology counts) | AI-CHAIN.1 (explicit via bidirectional witness) |
| Trust mesh | Basic (single crew boundary) | Full (cross-boundary, bidirectional verification) |
CrewAI organizes multiple AI agents into crews that collaborate on complex tasks. The SWT3 adapter wraps the kickoff() method to capture the crew's execution:
| CrewAI Concept | SWT3 Capture | Evidence Field |
|---|---|---|
Crew execution (kickoff()) | AI-INF.1 anchor per crew run | Model ID, prompt hash (from inputs), response hash, latency, provider = crewai |
| Agent count | Captured in InferenceRecord | inputTokens = number of agents in the crew (topology evidence) |
| Task count | Captured in InferenceRecord | outputTokens = number of tasks assigned (topology evidence) |
| Inputs | Serialized and hashed | Inputs dictionary is JSON-stringified and SHA-256 hashed as the prompt hash |
| Agent identity | AI-ID.1 when configured | Agent ID hash + optional HMAC-SHA256 signature |
The agent count and task count fields provide topology evidence: they prove how many agents participated and how many tasks were assigned, without exposing the task content. This is useful for auditors verifying that multi-agent governance was applied to workflows of a certain scale.
Google's Agent-to-Agent (A2A) Protocol standardizes inter-agent messaging. The SWT3 adapter wraps both directions of communication:
| A2A Operation | SWT3 Procedure | Evidence Produced |
|---|---|---|
Outbound message (send()) | AI-TOOL.1 | Message content hash (prompt hash), response hash, latency, provider = a2a |
Inbound message (handleMessage()) | AI-ACC.1 | Message content hash (resource hash), scope hash, outcome (processed/rejected) |
| Agent identity | AI-ID.1 | Each side of the communication carries its own agent ID hash |
Bidirectional witness is the key differentiator. When Agent A sends a message to Agent B:
This bidirectional pattern proves that both sides of the communication occurred and that the message was not altered in transit. When combined with the SWT3 Trust Mesh, agent trust levels can be verified before accepting messages (AI-TRUST.1/TRUST.2).
CrewAI does: The kickoff() method launches the full crew workflow. Multiple agents collaborate on assigned tasks. The crew returns a consolidated result.
SWT3 witnesses: Each kickoff() produces a single AI-INF.1 anchor capturing the crew execution. The inputs dictionary is hashed as the prompt. The agent count and task count provide topology evidence. The consolidated result is hashed as the response.
AI-INF.1 anchors from CrewAI captures show the crew execution timeline. The inputTokens field (agent count) and outputTokens field (task count) prove the scale of multi-agent coordination. A crew with 5 agents and 12 tasks will show inputTokens=5, outputTokens=12.
A2A does: Agent A invokes send() to deliver a message to Agent B. The message can be text, JSON, or a complex structured object.
SWT3 witnesses: The send() method is wrapped to produce an AI-TOOL.1 anchor. The message content is stringified and SHA-256 hashed. The anchor proves that Agent A sent a specific message at a specific time.
AI-TOOL.1 anchors from A2A send() operations document outbound agent communication. The prompt hash contains the message content hash. Match this hash against the AI-ACC.1 anchor on the receiving side to prove end-to-end message integrity.
A2A does: Agent B's handleMessage() receives and processes a message from Agent A.
SWT3 witnesses: The handleMessage() method is wrapped to produce an AI-ACC.1 anchor. The received message content is hashed. Factor C records whether the message was processed (1) or rejected (0).
AI-ACC.1 anchors from A2A handleMessage() operations document inbound communication. The resource hash should match the prompt hash from the corresponding AI-TOOL.1 anchor on the sending side. Hash mismatch indicates message tampering between agents.
CrewAI: The crew's agent count and task count provide implicit chain evidence. A crew of N agents executing M tasks represents a workflow chain.
A2A: The bidirectional witness (AI-TOOL.1 send + AI-ACC.1 receive) creates explicit chain links. Multiple linked exchanges build a full communication graph.
SWT3 witnesses: AI-CHAIN.1 captures the chain length, a hash of the chain composition, and the completion status. The references field links individual anchors into a verifiable chain.
For CrewAI: the agent/task counts in AI-INF.1 anchors plus any AI-CHAIN.1 anchors show workflow topology. For A2A: follow the AI-TOOL.1 and AI-ACC.1 anchor pairs, matching content hashes to trace the full communication path. The references field on each anchor links them into a verifiable sequence.
Both frameworks: Each agent in a multi-agent system should have a distinct, verifiable identity.
SWT3 witnesses: When agent_id is configured per agent, each agent produces anchors with its own identity hash. In CrewAI, the crew-level anchor carries the crew identity. In A2A, each agent's send() and handleMessage() anchors carry their individual identity. With signing_key, identity is cryptographically bound via HMAC-SHA256.
Distinct agent ID hashes across anchors prove which agent did what. In A2A, matching the agent ID in an AI-TOOL.1 (send) anchor against the agent ID in the corresponding AI-ACC.1 (receive) anchor proves which two agents communicated. This is the foundation of trust mesh verification.
| Examiner Question | Where to Look |
|---|---|
| How many agents participated in this workflow? | CrewAI: inputTokens field in AI-INF.1 anchors = agent count. A2A: count distinct agent ID hashes across AI-TOOL.1 and AI-ACC.1 anchors. |
| Did Agent A actually send a message to Agent B? | AI-TOOL.1 anchor (Agent A, send) and AI-ACC.1 anchor (Agent B, receive) with matching message content hashes. |
| Was the message altered between agents? | Compare prompt hash in AI-TOOL.1 (sender) against resource hash in AI-ACC.1 (receiver). Match = intact. Mismatch = altered. |
| Can you trace the full multi-agent workflow? | Follow the references field across anchors. AI-CHAIN.1 anchors summarize the chain length and completion status. |
| Can you prove each agent's identity? | AI-ID.1 in every anchor. Each agent has a distinct hash. Factor B = 1 for HMAC-signed identity. |
| Is this evidence independent of the orchestration platform? | Every SWT3 Witness Anchor is verifiable at sovereign.tenova.io/verify. Evidence exists outside both CrewAI and A2A infrastructure. |
Full SDK documentation: sovereign.tenova.io/docs
Create a free account: sovereign.tenova.io/signup