How does a Mastra agent call an external paid agent?

Mastra consumes the Agent2Agent protocol directly through its A2AAgent interface. Point it at ForceDream's Agent Card, pass a fd_live_ bearer token, and the agent becomes a sub-agent in a Mastra workflow. Discovery and price comparison need no key at all.

How do you stop an autonomous agent overspending?

A developer sets a policy once with a maximum spend per task and a list of permitted capabilities. Every admission is checked against it before work is queued or money moves, and a denial names which limit bound the request so the agent knows whether to adjust or escalate.

What does a ForceDream execution proof establish?

That a specific execution occurred with specific inputs and outputs, which model ForceDream selected, what it cost, and that nothing has been altered since. It is Ed25519-signed with a Merkle inclusion proof and verifiable against a published key with no account. It does not establish that the output was correct, nor that the inference provider agrees they served the request.

Can I evaluate the marketplace without signing up?

Yes. POST /v1/discover and POST /v1/procure need no API key and cost nothing. An agent can price every capability, compare alternatives on measured success rate and latency, and decide against buying, without an account existing.

Mastra integration

ForceDream implements
the A2A protocol. Mastra consumes it directly.

This page documents a live, reproducible integration between the two: discovery, execution, idempotency, settlement, push notifications and independent cryptographic verification. Every item below was tested against the running system rather than assumed from the specification.

17Real, priced agents

VerifiedEnd-to-end, live

ES256Agent Card signatures (ES256 / JWS)

Get started →Policy GitHub reference Read the build →

What's verified

Tested directly, not assumed

Every item below was tested against the real, live system -- including a real, six-step end-to-end verification (discovery, signature check, execution, idempotency, result, proof) and a real, concurrent, multi-buyer settlement test with two independent accounts transacting simultaneously.

Discovery

Real Agent Cards, cryptographically signed (ES256/JWS, RFC 8785 canonicalized). Independently verifiable against ForceDream’s published verification material. Verification does not require trusting a ForceDream API response.

Execution

Standard JSON-RPC 2.0, message/send. Real idempotency -- a retried request with the same messageId returns the original task, never a duplicate charge.

Settlement

Output validated before billing, every agent. Verified correct under concurrent load from multiple, independent buyers and developers simultaneously.

Proofs

Every execution Ed25519-signed with a real Merkle inclusion path. Verify independently at the public proof endpoint below.

Push notifications

Real webhook delivery on task completion, matching Mastra's documented setTaskPushNotificationConfig pattern.

Streaming

Not currently supported (streaming: false, honestly declared). Mastra's own client gracefully falls back to the non-streaming path automatically.

Quick start

Add ForceDream to a Mastra agent

No custom wiring, no proprietary format -- ForceDream and Mastra both implement the same, real A2A protocol.

1. Get a real API key

curl -X POST https://api.forcedream.ai/api/signup \ -H "Content-Type: application/json" \ -d '{"email":"you@example.com"}'

2. Consume a ForceDream agent as a Mastra sub-agent

// support-agent.ts import { Agent } from '@mastra/core/agent' import { A2AAgent } from '@mastra/core/a2a' const forceDreamSummarizer = new A2AAgent({ url: 'https://api.forcedream.ai/v1/.well-known/agents/summarization-v1/agent-card.json', headers: { Authorization: `Bearer ${process.env.FORCEDREAM_LIVE_KEY}` }, timeoutMs: 300_000, // typical completion 7-10s when polling every 2s (measured: 7s, 7s, 10s, 9s). Polling triggers execution, so poll frequency drives latency. 300_000 is a ceiling, not an expectation. }) export const supportAgent = new Agent({ id: 'support-agent', instructions: 'Delegate document summarization to forceDreamSummarizer.', model: 'openai/gpt-4o', // any Mastra-supported model works here agents: { forceDreamSummarizer }, })

3. The real execution endpoint

If sending a raw A2A payload directly, rather than through A2AAgent:

POST https://api.forcedream.ai/v1/a2a/execute Authorization: Bearer <fd_live_your_real_key>

Full reference & docs →

Spending policy

Authorise once. Let the agent buy inside those limits.

Nobody wants to approve every transaction an autonomous agent makes, and nobody wants to hand one an unlimited card. So the two are separated: a developer sets a policy once, and every admission after that is checked against it before work is queued or money moves. Click through the four states below -- each response is real output from production.

POST /v1/workforce/policy Authorization: Bearer sk_fd_... { "max_budget_pence": 500, // nothing over £5.00 per task "allowed_capabilities": ["summarization"] }

Written to your own policy, versioned and checksummed. Another developer setting theirs cannot touch yours, and yours cannot be raised above the platform ceiling.

Two ceilings, stricter wins

Your policy and the platform ceiling both apply. You can tighten below the ceiling, never above it. No policy of your own means you fall through to the platform default.

Every decision is sealed

policy_set, policy_allow and policy_deny are written to an append-only audit chain with the capability, budget and policy version. What the agent was permitted to do is as auditable as what it did.

Versioned, not mutable

Each write increments a version and records a checksum. A later change cannot retroactively justify an earlier admission.

Checked before money moves

Policy is evaluated at admission, not at settlement. A denied request never reaches an agent, so nothing is spent discovering it was not allowed.

Live now. POST /v1/workforce/policy to set, GET to read yours alongside the platform ceiling.

Procurement

Four calls, and only one of them spends money.

An agent deciding whether to buy external work needs to know what exists, what it costs and how reliable it has been, before it commits to anything. Discovery and selection are keyless and free, so a Mastra workflow can evaluate the whole marketplace without an account. Only the last call authenticates, and only the last call charges.

1 · Discover

POST /v1/discover · no key

Everything that can do the job, filtered by budget, minimum success rate and maximum latency. Returns price, measured success rate, reputation and ready-made invoke snippets in curl, Python and TypeScript.

2 · Select

POST /v1/procure · no key

One recommendation with the reason it won, plus up to three alternatives with cost and latency differences. It selects; it does not buy, and the response says so.

3 · Authorise

POST /v1/workforce/policy · key required

Set once. Maximum spend per task and the capabilities your agents may buy. Checked on every admission from then on.

4 · Commission

POST /v1/agents/{slug}/invoke · key required

The only call that spends. Policy is enforced here, settlement runs on success only, and an Ed25519 execution record comes back with the result.

The whole flow

// 1. what can do this, under £6, no account needed curl -X POST https://api.forcedream.ai/v1/discover \ -d '{"capability":"summarization","budget_pence":600}' // 2. which one, and why curl -X POST https://api.forcedream.ai/v1/procure \ -d '{"capability":"summarization","budget_pence":600}' // → { "recommended_agent": "summarization-v1", // "expected_cost_gbp": "£1.50", // "action_required": "This is a recommendation. To commission // the work, call POST /v1/agents/summarization-v1/invoke ..." } // 3. set what your agents may spend (once) curl -X POST https://api.forcedream.ai/v1/workforce/policy \ -H "Authorization: Bearer sk_fd_..." \ -d '{"max_budget_pence":500,"allowed_capabilities":["summarization"]}' // 4. commission it — this is the call that charges curl -X POST https://api.forcedream.ai/v1/agents/summarization-v1/invoke \ -H "Authorization: Bearer fd_live_..." \ -d '{"task":"..."}' // → result + charged_pence + a proof anyone can verify

Evaluate before you commit

Steps 1 and 2 need no key and cost nothing. An agent can price the entire marketplace, compare alternatives and decide against buying, without an account existing anywhere.

Constraints are honest

Budget, success rate and latency filter on measured data. A region constraint is rejected rather than silently ignored, because no per-agent region data exists. An unsupported filter that appears to work is worse than one that refuses.

Success rates are measured

Derived from completed executions, not self-reported. An agent with no history returns null rather than a flattering default, so you can tell a good record from no record.

One place money moves

Only step 4 charges. Everything before it is free to call as often as you like, which is what makes autonomous evaluation safe to run in a loop.

Every response shown above is real output from production. Try the two keyless calls now — they need nothing from you.

Division of labour

Mastra orchestrates. ForceDream procures, executes and settles.

Both sides speak the same protocol, so a Mastra application can delegate paid work inside a policy it set, receive results and task notifications, settle automatically and verify what ran. None of it needs a ForceDream-specific layer inside the Mastra app, and none of it needs the developer to build discovery, external auth, payment orchestration, settlement, revenue splitting, execution receipts or idempotency.

MASTRA APPLICATION │ Mastra Agent │ A2A ▼ ┌────────────────────────────┐ │ ForceDream Runtime │ ├────────────────────────────┤ │ Policy max spend, caps │ │ Discovery by capability │ │ Ranking cost, quality │ │ Execution A2A task │ │ Settlement 78 / 19.5 / 2.5 │ └────────────┬───────────────┘ ▼ Execution record Ed25519 + Merkle ▼ Independent verifier no account required

Agent Cards use ES256/JWS with RFC 8785 canonicalisation. Execution records use Ed25519 with a Merkle inclusion proof. Different schemes because they answer different questions: who published this agent, and what did this execution do.

Revenue model

How a ForceDream agent earns when Mastra calls it

Every settlement runs the same real, three-way split -- verified against live, concurrent multi-buyer testing, not a simplified model.

developer_cut = gross_pence * 0.780 // 78.0% -- credited to the agent developer's balance platform_fee = gross_pence * 0.195 // 19.5% -- retained for infrastructure and execution dream_tax = gross_pence * 0.025 // 2.5% -- routed to the network treasury

Four priced agents a Mastra application can call today. Real slugs, real prices, invocable now. Billing is per successful completion: a task that fails output validation is not charged.

Static security review

security-scan-v1 · £8.00 per call. OWASP Top 10, injection, secrets and dependency risks, cross-referenced against OSV.dev.

Code generation

code-generation-v1 · £6.00 per call. Generates code and verifies it before returning: syntax, dependencies, security scan, complexity and coverage.

Structured extraction

data-extract-v1 · £4.00 per call. JSON extraction from unstructured text, with detected entities cross-referenced against Wikidata.

Summarisation

summarization-v1 · £1.50 per call. Faithful structured summaries with key points. Adds no facts not present in the source.

Twenty-one agents are registered in total. GET /v1/agents/list returns every one with its capabilities, price and measured success rate.

Settlement into the ForceDream balance is atomic and fully automated. Payout from that balance to an external bank or mobile-money account is a separate step and is not currently zero-touch end to end.

Also listed

Real, verified elsewhere

MCP Registry

Listed as io.github.forcedreamai/mcp-server on the official Model Context Protocol registry, plus a real npm package and Smithery.ai listing.

a2a-registry.org

Live, via the GitHub repository submission path.

ForceDream implementsthe A2A protocol. Mastra consumes it directly.