What synth.muse is

Build an agent, get paid in tokenised stocks every time someone runs it.

The idea

Most agent marketplaces pay builders in a token that exists so the marketplace can pay builders in it. synth.muse pays in the thing people already want: a share of a company, as a tokenised stock on Robinhood Chain.

You write a manifest. synth.muse hosts and runs it. Every run is metered and paid in USDG by the person who ran it. Your share converts into the stock you named in the manifest and settles to your wallet every Monday. You never invoice anyone and never claim anything.

What “autonomously” means here

• You do not run a server. The runtime is synth.muse’s.
• You do not collect payment. The run is paid before it starts.
• You do not request a payout. Settlement is a scheduled transfer, one transaction per agent per week, linked from the ledger.
• You do not pick a price for the stock. The conversion uses the registry reference price at run time, and the formula is one division.

What you control

Everything in the manifest: the system prompt, the tools, the price per run, your share, the stock you are paid in — and the muse. Every agent on synth.muse is a muse: a small plush figure in a fur hood, with a smooth face and two black eyes. You design it on /build; it sits on the agent’s card, its eyes follow visitors, and the coin it holds is the stock it earns you. Change any of it by publishing a new version.

What synth.muse is not

It is not a yield product. If nobody runs your agent, nothing vests. You are paid in stock, never in a house token: $SYNTHMUSE is not part of the payout. Stock tokens carry an ERC-8056 multiplier — a dividend or a split changes what a unit is worth — so your balance is a share count, not a dollar figure.

Building real agents

Tools, knowledge, structured output, a step budget and a test bench — what separates an agent from a chatbot.

What a synth.muse agent is

A chatbot answers from what it remembers. An agent goes and gets what it needs, does the work, and returns something another program can use. On synth.muse that means five things in the manifest, all optional, all real.

1. Tools

The runtime declares the server tools to the API and executes the local ones itself, with your allow-lists enforced before any request leaves the box. The agent decides when to call a tool; brain.maxSteps caps how many times it may run.

2. Knowledge

knowledge is a list of documents the agent always has in front of it: an API reference, a pricing sheet, a style guide, last quarter’s numbers. They are sent as a cached system prefix, so after the first run they cost almost nothing. 120,000 characters in total.

3. Output

output.format: "json" with a JSON Schema makes the answer a validated object instead of prose — the schema is passed as output_config.format, so the model is constrained to it. That is how an agent becomes something another program can call. Earnings Caller and Scheduler in the catalog do this.

4. Brain

brain.effort (low → xhigh) sets how hard the model thinks; brain.maxSteps how many tool calls it may make; brain.maxTokens how long the answer may be. fewShot pins the format with worked examples.

5. The test bench

/build runs your draft exactly as the runtime will — tools, knowledge, schema — without publishing or recording anything, and shows the trace: every tool call, its input, its result, how long it took. Iterate there until the trace looks right. POST /api/build { step: "test", manifest, prompt } does the same thing from a script.

The trace

Every run returns a trace and stores it with the run: server tool calls, local tool calls with their inputs and truncated results, and the final answer. It is shown under the answer on the agent page. It is how a user sees that the agent did the work rather than made it up.

Export

Every manifest is a file. Download it from the agent page or the builder (/api/agents/[id]/manifest), keep it in git, edit it, and POST it back to /api/build.

The manifest

One JSON file is the whole agent. Here is every field.

Shape

{
  "manifest": 2,
  "id": "briefer",
  "name": "Briefer",
  "tagline": "Turns any thread, doc or transcript into a one-page brief.",
  "description": "…",
  "category": "Writing",
  "system": "You are Briefer. …",
  "model": "claude-opus-5",
  "brain":    { "effort": "medium", "maxSteps": 5, "maxTokens": 4000 },
  "tools":    ["web_fetch", "clock"],
  "output":   { "format": "text" },
  "examples": ["Brief this: [paste a meeting transcript]"],
  "pricing":  { "perRun": 0.25, "currency": "USDG" },
  "vesting":  { "stock": "NVDA", "builderShare": 0.7 },
  "builder":  { "handle": "mara.eth", "wallet": "0x6c19…4e18" }
}

The JSON Schema is served at /api/schema. Every listed agent’s manifest is at /api/agents/[id].

Fields

Publishing

Either use /build, which writes the file with you, or POST the JSON yourself. Publishing takes one signature: the payout wallet signs a message naming the agent and itself, so nobody can list an agent that vests to an address they do not control. /build asks your wallet for it; by hand it is one wallet.signMessage and a signature field next to the manifest.

The studio opens as a co-pilot: describe the agent in a sentence and it interviews you, writing the manifest as you answer — system prompt, tools, allow-list, output shape, example prompts. Everything it writes lands in the steps, where you can rewrite any of it; the studio, not the chat, is the source of truth. Six templates sit under the chat for a faster start, your draft is kept in your browser between visits, and you can snapshot a session before rewriting the prompt. A system prompt may carry {{placeholders}} and the value you ask for each one is baked into the manifest when it is written.

curl -X POST https://synthmuse.app/api/build \
  -H 'content-type: application/json' \
  -d '{"step":"publish","manifest":{ … }}'

Validation errors come back as a list with the field name. A taken id is a 409.

Vesting math

One division, two constants, weekly settlement.

Per run

builderUSDG = perRun > 0 ? perRun × builderShare : 0.02
units       = builderUSDG ÷ refPrice(stock)

• perRun and builderShare come from the manifest.
• 0.02 USDG is the usage grant: what a free agent vests per run. It comes from the runtime margin on paid agents.
• refPrice is the stock token’s reference price in the Robinhood Chain registry at the time of the run. No spread, no rounding beyond the token’s 18 decimals.

Example

Briefer charges 0.25 USDG, keeps 70%, pays in NVDA at a reference of $207.37:

0.25 × 0.70 = 0.175 USDG
0.175 ÷ 207.37 = 0.000844 NVDA per run

4,812 runs later that is 4.06 NVDA. The calculator does this live for any inputs.

Settlement

Accrued units roll into a pending row in the ledger, one per agent. Every Monday at 15:00 UTC a scheduled job calls vestMany on the treasury contract: one transaction for the whole week, one Vested event per builder, and each row gets that hash. Runs made after 15:00 UTC open the next week’s row. A row the treasury cannot cover stays pending and says so rather than being quietly dropped.

Why a stock and not a token

Because a builder should be paid in something that exists whether or not synth.muse does. A share of NVIDIA does. A marketplace token only exists so the marketplace can pay you in it.

The multiplier

Robinhood Chain stock tokens implement ERC-8056: your raw balance never changes; a per-token multiplier does. When the underlying pays a dividend or splits, the multiplier moves and every balance is reinterpreted through it. synth.muse vests units of the token, so a dividend after settlement is yours. Nothing here is investment advice.

Runtime

How a run executes, what the model sees, what gets hashed.

The call

Each run is one request to Claude (claude-opus-5 unless the manifest says otherwise) with:

1. the manifest’s system prompt, cached as a stable prefix;
2. a second system block naming the builder and payout stock, so the model can answer “who made you”;
3. the user’s prompt as the single user message.

Adaptive thinking is on. Streaming is used so long answers do not time out. Server-side refusal fallbacks are enabled, so a policy decline re-runs on a fallback model inside the same call instead of returning nothing to a paying user. A refusal that survives the fallback is returned as text and is not charged.

The digest

digest = sha256(prompt + "·" + output)

It is stored with the run and shown on the agent page. It exists so a run can be re-verified later without trusting synth.muse’s database.

Demo mode

Without ANTHROPIC_API_KEY, the runtime returns a labelled deterministic stand-in and still records the run and its reward, so the whole loop — run, accrue, settle — works on a fresh clone. Set the key in Vercel and the same button runs the real model.

Tools

tools is executable, not decorative. The local tools — chain, http, memory, clock — run on synth.muse with your allow-lists enforced before the call, and they run even in demo mode: a chain read really reads Robinhood Chain. The server tools — web_search, web_fetch, code — execute on Anthropic’s side inside the same call, so they need ANTHROPIC_API_KEY on the server; without it the trace says so instead of pretending.

Settlement & the chain

Robinhood Chain, the stock registry, and what a settlement transaction looks like.

The chain

Robinhood Chain, id 4663, EVM. Explorer: robinhoodchain.blockscout.com. Runs are paid in USDG (0x5fc5…d168, 6 decimals).

The stocks

The 47 tokenised stocks are ERC-20s (18 decimals) behind a single beacon, 0x10c9…1b00, which holds the shared implementation, the roles and the blocklist. The registry snapshot synth.muse reads is served at /api/stocks with each token’s address and reference price.

A settlement

The contract is SynthTreasury — 120 lines, in contracts/src in the repo, with its tests. It does two things and nothing else:

function payRun(bytes32 agentId, uint256 amount, bytes32 runRef) external;
function vestMany(bytes32[] agentIds, address[] builders, address[] tokens, uint256[] units, uint64 weekId) external;

payRun pulls USDG from the runner and emits RunPaid, which is the receipt the runtime reads back from the chain before it spends anything. vestMany moves units of the tokenised stock to each builder and emits Vested, which is what a ledger row links to. It never prices anything: the split lives in the manifest, and the arithmetic is on /vesting.

The contract is written and tested but not yet deployed — the treasury address holds no ETH — so the historical rows on this deployment are seeded for illustration and labelled as such. Pending rows accrue from real runs and wait.

Paying for a run

If an agent has a price the run can pay it on chain: approve the treasury for the exact amount, call payRun, then send the transaction hash with the run. The server fetches that receipt itself, checks the agent, the amount and that the hash has not already bought a run, and only then calls the model. Without a receipt the run is a usage grant — free, rate-limited, and vesting from the runtime’s margin exactly as the manifest says.

API

Seven endpoints, no auth, CORS open.

curl https://synthmuse.app/api/run \
  -H 'content-type: application/json' \
  -d '{"agent":"sqlsmith","prompt":"monthly active users by plan, postgres"}' | jq .run.reward

FAQ

The questions builders ask before their first manifest.

Do I need to hold anything to list?

Not today, and if a gate is switched on it will be a minimum balance checked at publish, never a lock. Publishing is open to everyone until a minimum is set. You need a wallet address on Robinhood Chain to be paid to either way.

Can I be paid in more than one stock?

One stock per agent. Build two agents if you want two stocks — or republish with a different vesting.stock: future runs vest the new one.

Who pays for the model?

The non-builder share of each paid run. That is why builderShare is capped at 90%: the remaining 10% is the floor for the runtime. Free agents are funded from that margin through the usage grant.

What if the reference price is stale?

The registry snapshot is what the chain publishes; synth.muse does not mark its own prices. If a stock has no reference price it cannot be selected.

Can someone run my agent a million times to farm stock?

A paid run costs the farmer more than it vests, and the payment receipt is checked on chain and can only be spent once. Free runs come out of the usage grant and are capped: 10 an hour and 40 a day per address, 300 a day per agent, and a site-wide ceiling above that.

Where is my agent’s data?

The manifest is public by design (it is the agent). Prompts and outputs are stored with their digest for the run history and are not used to train anything.