Evidence rails for agent workflows
Let agents do the work. Keep the workflow accountable.
Your agent drafts an answer, calls a tool, asks another agent to verify it, records a decision, or sends context to a partner. The work may stay inside one org or cross into another. Either way, you need to know what happened.
Mintbaton gives developers a messaging and SDK layer for agent identity, encrypted handoffs, workflow checkpoints, recorded decisions, delivery, and acknowledgement.
| sender | claims-agent@payer.example · agent 8f21c3 |
|---|---|
| recipient | eligibility-agent@provider.example · agent 2d91aa |
| represents | Northstar Health Plan · delegated by ops-admin@payer.example |
| authority | current eligibility.verify.read · expires 2026-09-01 |
| delegation | no onward delegation permitted |
| context policy | member_id, plan_code allowed · diagnosis, notes denied |
| projection | MCP capability eligibility.verify · schema provider-eligibility-v1 |
| encrypted | true · X25519 sealed to recipient agent key |
| signature | verified Ed25519 over canonical envelope |
| envelope hash | sha256:41c7e2…9ab4 · retained after payload redaction |
| checkpoint | eligibility_matched · policy version 2026-08-20 |
| decision | proceed_to_prior_auth · recorded by eligibility-agent@provider.example |
| acknowledged | 2026-08-24T14:11:09.320Z |
Agent workflows need a system of record.
Service logs can tell you an API call happened. They do not always tell you which agent made the call, what authority it carried, what checkpoint it reached, or why the next step ran.
That gets harder as workflows move from one agent to many, from one team to another, and from one organization to a partner. Mintbaton gives developers a place to record the message, the trust checks, and the process decisions that matter later.
The receiving party needs more than a message. It needs a reason to trust the handoff.
| Challenge | What gets harder | What Mintbaton records |
|---|---|---|
| Agent identity | The recipient must know whether the agent is legitimate, who owns it, which human or business it represents, and whether delegated authority is still current. | Verified agent identity, owning organization, published key, handshake state, and the delegation claim attached to the exchange. |
| Authorization | Access alone is too broad. The hard questions are what the agent may do, what data it may retrieve, whether it may delegate, and who may receive context. | Scoped permission labels, expiry, counterparty relationship, delegation limits, and policy metadata bound to the envelope. |
| Trust and provenance | Requests, recommendations, documents, and transaction data must be authentic and unaltered even when temporary teams of agents assemble across organizations. | Signature state, canonical envelope hash, sender key confirmed at handshake, delivery time, and acknowledgement time. |
| Data leakage | Agents can pass customer data, pricing, contract language, regulated information, or trade secrets as context to another agent or tool. | Recipient-bound encryption, context policy labels, payload size, message type, and retention state without broker-readable contents. |
| Accountability | When a workflow exposes data, violates a policy, or commits to a transaction, responsibility can blur across deploying company, vendor, model, tool, and counterparty. | A neutral chain of who requested what, under which authority, which agent acknowledged it, and when each step occurred. |
| Audit and disputes | Application logs are fragmented and self-reported, making it difficult to reconstruct an end-to-end decision or delegation chain after the fact. | A third-party, tamper-evident exchange record designed to survive payload redaction and later reconstruction. |
| Interoperability | Different stacks, APIs, schemas, identity models, and emerging protocols make safe communication brittle and expensive. | A small brokered envelope model with explicit identity, keys, permissions, message type, and acknowledgement semantics. |
| Reliability | An upstream error can trigger downstream action in another company's system; parallel agents can create conflicting outcomes. | Ordered handoff records, acknowledgement state, and exact byte hashes for the inputs each downstream agent received. |
| Compliance | Cross-entity workflows may move personal, financial, health, export-controlled, or confidential data across entities and borders. | Purpose and policy metadata, retention state, recipient identity, delivery record, and proof that the broker lacked plaintext access. |
| Commercial control | Autonomous chains can create unexpected inference, API, tool, and transaction costs that are hard to attribute fairly. | Per-counterparty exchange records with message type, direction, acknowledgement, and rate-limit surfaces for later allocation. |
Messaging, proof, and workflow checkpoints in one path.
Mintbaton gives your agent workflow a durable record: who acted, which key signed, what permission applied, what message moved, what checkpoint was reached, which decision was recorded, and whether the recipient acknowledged it.
The broker does not need to see the business data to prove the work. Customer records, pricing, contracts, prompts, and regulated content can stay sealed to the receiving agent. Mintbaton keeps the facts around the workflow.
- Identify agents
- Tie each agent to an organization, public key, human or business principal, and current delegation context.
- Bound the request
- Attach scope, expiry, allowed context, counterparty, and delegation rules to the envelope itself.
- Prove messages
- Record signature checks, exact byte hashes, delivery, acknowledgement, and key state.
- Capture checkpoints
- Let application code record workflow milestones, policy checks, approvals, refusals, and agent decisions.
- Keep payloads private
- Seal payloads to recipient agents before broker receipt, redact ciphertext on schedule, and keep only proof metadata.
- Reconstruct work
- Follow the chain of request, delegation, context policy, checkpoint, decision, handoff, and acknowledgement.
Small envelope. Clear checks. Workflow events your code can emit.
Register each agent with signing and encryption public keys. Private keys stay in your runtime.
Model the workflow steps you care about: policy checks, approvals, tool calls, decisions, and handoffs.
Have the sender encrypt the payload to the recipient, sign the envelope, and include permission, protocol, projection, and context policy metadata.
Use the SDK to record checkpoint and decision events as agents move through the process.
Mintbaton checks relationship, key state, scope, and rate limits, then records metadata and hash before delivering ciphertext.
The recipient verifies the signature, decrypts locally, acts or refuses, and acknowledges receipt.
Bring the protocol your agents already use.
Mintbaton does not decide whether agents communicate through MCP, A2A, HTTP, queues, webhooks, a vendor SDK, or a private contract between two runtimes. That choice belongs to the agents and the teams or counterparties they transact with.
The platform provides metadata and structures so those choices are visible: protocol family, version, address, capability, schema, external run ID, tool call ID, workflow checkpoint, and agent projection. Readers can see what kind of agent was acting, through which interface, without Mintbaton becoming the protocol itself.
Use Mintbaton where "what happened" needs a durable answer.
- Internal agent operations: record reviews, approvals, escalations, and decisions as work moves across teams and systems.
- Agent products and platforms: give customers evidence when your agents act for them, with them, or on their behalf.
- Procurement and supplier workflows: prove which agent requested terms, what authority it had, and which offer was acknowledged.
- Insurance and healthcare operations: exchange eligibility, authorization, claim, or scheduling context without exposing plaintext to the broker.
- Regulated automation: preserve evidence of purpose, recipient, permission, retention, checkpoint, decision, and acknowledgement.
Built for the trust shape agents are converging on.
The pieces are familiar: publishable agent identity, signed metadata, explicit relationships, scoped delegation, provenance, recipient-checkable proofs, and application-defined workflow events. Mintbaton packages those pieces as working infrastructure instead of waiting for the standards dust to settle.
Today that means a hosted broker, TypeScript SDK, MCP path for pilots, and poll-based delivery. For teams that cannot route ciphertext through a third party, the design leaves room for an appliance path. No certification or standards-body endorsement is claimed yet.
Closed beta for teams wiring real agents into real processes.
Good pilots start with one concrete process: an internal review chain, partner data request, delegated approval, claims exchange, supplier commitment, external tool call, or vendor-run agent workflow where the customer needs proof independent of vendor logs.
- The protocol engine, handshake model, signing and sealing path, checkpoint capture, and metadata-only proof surface are running.
- Accounts are invite-only for pilot partners.
- The SDK and MCP server are available directly to pilots, not yet through public registries.
- Delivery is poll-based today; webhooks and push delivery should not be assumed.
- There is no public SLA, public status page, SOC 2, HIPAA, HITRUST, ISO certification, or BAA yet.
Bring us a workflow
If agents make decisions inside your process, give the work a record.
The most useful demo starts with your real flow: who the agent represents, what authority it has, what context moves, which checkpoints matter, what decisions get made, and what would be painful to reconstruct later.
Invite-only. Small cohort. Direct access to the people building the protocol.
Mintbaton
Mintbaton is a hosted broker and evidence layer for agent workflows inside and between organizations.
What it does
- Registers agents with public signing and encryption keys.
- Associates each agent with an organization.
- Requires counterparties to establish a contact relationship before message exchange.
- Receives encrypted agent messages.
- Verifies sender identity, relationship, signature, key version, and envelope hash.
- Stores protocol and agent-projection metadata without dictating how agents communicate.
- Records workflow checkpoints and decisions emitted through the SDK.
- Stores message metadata, envelope hashes, and proof material.
- Does not read message plaintext.
- Delivers messages by polling.
- Records recipient acknowledgement.
What it is for
Mintbaton is for workflows where agents send information, instructions, or context, and where teams need a durable record of messages, checkpoints, and decisions.
Use it if
You need a neutral record of which agent sent which encrypted envelope, under which authority and key state, what process events were recorded, and whether the recipient acknowledged it.