Work Has to Clear
The clearing layer for autonomous work — price, route, execute, and settle every task, human or agent, with a signed receipt of what happened and what it cost.
Software is starting to do its own work. Agents and humans now pull from the same queues, and something has to decide what each task is worth, who should do it, whether it was actually done, and who gets paid. That is a clearing problem, and nobody built the layer for it.
Ductor is that layer. It prices a unit of work, routes it to the best worker — human or agent — runs it to completion on a durable engine, settles the money, and signs a receipt proving what happened and what it cost.
you route work at volume — leads, tickets, tasks, inference calls — and you have been assembling an execution engine, an integration catalog, a decision layer, a billing pipeline, and an audit trail from separate parts, owning every seam between them.
The shift
The unit of coordination used to be "run this function." It is becoming "get this task done, by whoever is best, and prove it." A workflow engine answers did it run. It does not answer what was it worth, who should do it, or was it done well enough to pay for. Those are market questions, and they arrive the moment the worker on the other side is autonomous — an agent that can take work, bid on work, and complete work only if the infrastructure can enforce its budget, meter its cost, govern which actions it may touch, and produce a record a human can audit.
The gap
We have execution engines, integration catalogs, and agent frameworks. None of them decides what work is worth, who does it, or whether it was done. Everyone assembles that from parts and owns the seams — and the seams are where work silently vanishes, gets double-sent, or becomes unbillable and unprovable.
- Execution engines
- Durable retries and timers — no price, no market, no settlement.
- Integration platforms
- A catalog of endpoints — no machine-readable semantics, no clearing.
- Agent frameworks
- Checkpoints and traces — ungoverned tools, no receipts, no ledger.
- Ductor
- One engine, one state model, one audit spine — priced, routed, executed, settled, proven.
What clearing means
Borrow the one honest metaphor. A clearinghouse does five things: it prices, it matches, it guarantees execution, it settles the money, and it produces a record. Ductor has a plane for each — and unlike the metaphor, every plane is code you can read.
- Every task has a price before it moves
Fixed, expression-based, or discovered by a market. shipping
- The best worker, chosen and explained
Strategies rank candidates; every decision carries its reason. shipping
- It runs to completion, or fails where you can see it
A durable coordinator/worker engine — the boring guarantee under the rest. shipping
- The money moves, and reverses when work fails review
A ledger charges, credits, and claws back inside a warranty window. shipping
- One signed receipt per outcome
Decision, tool manifests, cost, and consent, joined into one verifiable object. shipping
Priced
Work without a price cannot clear. A pool prices work by a fixed rate, by an expression over the work's attributes, or by letting a market discover the price — ping/post sessions, sealed-bid auctions, reverse Dutch listings that decay to a floor, standing buy orders that match automatically.
shippingbuyer-8462.50wins · pays 57.25buyer-1257.25second pricebuyer-3144.10outbidbuyer-0738.00below floorThe winner pays the second price, and the floor is computed from recent bids and demand — not guessed.
Auction clearing with a vickrey_second_price algorithm, ping/post bidding,
reverse-Dutch listings, standing buy orders, and dynamic floor pricing driven
by a yield model.
Routed
The decision is the intelligence, and it must be explainable. A Route binds Work to a Worker and carries the reason the winner won — who was eligible, how they scored, why they were chosen. Strategies are pluggable, versioned, and testable in shadow against production traffic before you trust them. shipping
agent · closer-oak0.91assignedteam · north-desk0.84runner-uphuman · j-alvarez0.77eligiblereason: highest predicted conversion within SLA · thompson_sampling@v3 · every score is in the record
A routing pipeline of Validate → Enrich → Filter → Select → Assign, 20+
strategies including Thompson-sampling and LinUCB bandits, shadow campaigns
with divergence guardrails, and a per-decision explanation
(Route (Decision) plus its Explanation).
Executed
Durable by construction — the boring guarantee that makes everything above it safe. A single-writer coordinator owns all run state; parallel workers do the side effects and only append results. Steps act on the world through a typed action catalog whose entries declare their own semantics — mutation class, idempotency, retry, approval — so the runtime, and any agent, knows what is safe to retry and what needs a human. shipping
Workers retry, wait, and escalate; only the coordinator commits state. A step that cannot land goes to the dead-letter queue — visibly.
The coordinator/worker model with record_version optimistic locking,
hundreds of connector providers whose actions declare semantics, and per-tenant
credential encryption at rest.
Settled
Money moves on a ledger and reverses when work fails review. Wallets support prepay with auto-top-up; postpay accumulates into invoices. Usage is metered across everything — routing decisions, connector actions, workflow steps, tool calls, tokens in and out. And because work can be bad, settlement is reversible by contract: a Warranty window during which the buyer can return the work for reasons on a defined code list, triggering an automatic credit and optional re-routing. Returns and claw-backs are market features, not support tickets. shipping
debitbuyer · acme-57 250 000creditworker · closer-oak+54 387 500creditplatform · fee+2 862 500netevery committed transaction balances0reversewarranty · work failed review · day 14entries mirroredA double-entry-style ledger, a returns window with automatic credit and re-route, Stripe prepay wallets and postpay usage invoicing, and usage metering denominated to the micro-unit. New work also settles on the dedicated balanced-entry work-settlement journal in integer micro-units, enabled per deployment behind a settlement flag.
Proven
Every consequential act should leave evidence. A Receipt joins
the route's explanation, a signed manifest for every tool an agent invoked, the
cost in exact units, the consent trail, and the settlement reference into one
verifiable object — the artifact you hand an auditor, a customer, or a
counterparty when they ask what exactly happened, and what did it cost. The
component evidence ships today, and the unified WorkReceipt now assembles and
Ed25519-signs it, with an offline verify surface — issuance is enabled per
deployment behind a config gate. shipping
- work
lead_9f42· converted- route
dec_01j8k…· thompson_sampling@v3 · explanation attached- tools
- 2 invocations · manifest
sha256:ab12…9e - cost
57 250 000µUSD- consent
trustedform:cert_77a…- settlement
stl_31c…· committed
Decision explanations, content-hashed tool-exposure manifests and receipts, consent certificates, and per-request cost accounting — the inputs the unified Work Receipt assembles and signs.
Human or agent, same rails
The deepest design decision in Ductor: an AI agent is just a Worker. The same capacity model, the same quality score, the same pricing, the same SLA clock. Governance is not a per-worker special case bolted on for agents; it is the layer. Agents run on a durable agent runtime with budgets and delegation, reach the world through a governed tool surface with least-privilege manifests and per-invocation receipts, and are metered like any other worker. An agent that overspends is stopped by the ledger, not by hope. shipping — including typed RFQ bidding by worker identity.
Where this goes
The lead economy is the beachhead, and it clears real work at volume today. The trajectory is to generalize the market: broadcast a task spec, let humans and agents bid on price, quality, and SLA, award by auction rules, execute durably, settle on the ledger, and claw back if the work fails review. It is twenty years of lead-market machinery — ping/post, broadcast-claim, returns — pointed at a new class of worker. Much of that now runs, each an opt-in surface, off by default: workers bid on price, quality, and SLA with typed terms; agents publish task specs and discover open ones over the API; connector actions and governed skills resolve prices; certified strategies price at adoption; a won bid clears into a durable run — the award pins the exact definition it launches, settles the escrowed price on the ledger when the work completes, and returns the hold to the buyer if the pins drift and the run never starts; and an agent's capped connector-action spend settles onto the balanced ledger as showback.
What remains is narrower than it was. A verified reputation plane — the fault-attributed award history and the projection that discounts a bidder's self-asserted quality by its settled record — is built; wiring it into live clearing is roadmap. An action price carries no payee, so a settled agent purchase credits the platform, not a marketplace seller: paying a publisher for a bought action is roadmap. And governed-skill spend is capped and priced but does not yet settle — a priced skill read leaves no durable execution record to settle from — roadmap.
The principle
Ductor extends one ethos it already holds — every path either succeeds correctly or fails visibly, no silent drops, no double-sends — from routing to money. Settlement fails visibly too: claw-backs, dead-letter queues, warranty returns. Honesty about failure is what keeps a receipt worth trusting.
Markets clear. Work settles. Receipts don't lie.
Introduction
Ductor is the clearing layer for autonomous work — it prices, routes, executes, and settles each task with proof, as a single Go binary you run inside your own platform.
The Clearing Primitives
Seven primitives describe everything Ductor does — Work, Worker, Bid, Route, Receipt, Settlement, and Warranty — and how each maps onto the API.