Documentation

What a connector is#

A connector is a curated project that sells named operations rather than raw compute. It runs in the same TEE as everything else here; what makes it a connector is that its prices live on chain and that we vouch for it.

Writing one? See Building a Connector — the manifest, the network allowlist, the answer format and what can refuse a call to you.

A request to one names the operation at the top of input:

POST /call/connectors.outlayer.near/<connector>
{ "input": { "operation": "send_email", ... } }

Each operation has its own price. An operation that is not on the list has no price at all and the call is refused — which is not the same as being free: a price of 0 is a real, published price and means the operation costs nothing beyond compute.

The author's share#

A connector is written by somebody, and that person is paid out of what the connector charges. The share is set per operation, in basis points of its price, and it is credited on chain when the call succeeds — to the author's account, not ours.

Per operation rather than per connector, deliberately: the economics of sending an email and of moving money are not the same number, so one share for a whole connector would have to be wrong for at least one of its operations.

Authors withdraw the same way every developer on OutLayer does — see Earnings. Nothing about the share depends on how the caller paid: money, allowance or trial, the author is credited the same.

Subscriptions#

A subscription turns a key's per-call charges into a flat allowance for the period the plan runs. Without one, each call takes the compute it used plus the operation's price out of the key's balance. With one, the same calls come out of the allowance instead.

• The allowance belongs to a key, not to an account. One account can hold several keys and subscribe only the one that needs it.
• A key can hold money and an allowance. The allowance is spent first; the balance is what keeps working when it runs out.
• Buying more never shortens what is already paid for — validity extends from whichever is later, today or the current expiry — and paying above a plan's price leaves the difference on the key as spendable balance rather than absorbing it.
• New calls stop being admitted slightly before the expiry, so a call already running is never cut off by the deadline arriving mid-flight.

Where the agent's key comes from. It is created once, with POST /wallet/v1/create-payment-key and {"agent": true}. No key string comes back and none is stored — the key is named after the wallet, and the wk_ you already hold is what spends it. A wallet has exactly one. Until it exists, GET /subscription/status with that wk_ answers 401 Missing X-Payment-Key header — the wallet has no key of its own to report on yet.

A subscription is bought for an AGENT's key. An agent has no payment key string to present — its wk_ stands for it, and the coordinator resolves the key from that. So the purchase names the key instead: an ft_transfer_call carrying {"action":"buy_subscription","nonce":N,"owner":"<agent>","plan":0}. The sender pays and the agent carries the allowance, so one transaction from your wallet subscribes an agent that owns nothing.

The wk_ itself buys nothing: it reads its own status, allowance and expiry and authorises nothing that spends. Buying, and choosing where warnings are sent, stay with the owner — a compromised agent should not be able to do them on your behalf.

Why the agent's key and not any key. Technically a subscription is not a special kind of key: it is an attribute an ordinary payment key can carry too. But a wallet has exactly ONE agent key, so "the agent's subscription" names one thing, while an account can hold many ordinary keys and each could carry a subscription of its own. Nothing merges them and nothing warns, so two subscribed keys means paying twice for one agent's worth of work. Our interface therefore offers the shape that cannot be got wrong — and if you ever do want several, on several agents, nothing stops you: it just rarely pays for itself at today's prices.

An ordinary payment key with no subscription is not second-class: it pays per call out of its balance and reaches exactly the same connectors. The subscription is a wholesale rate, not a different class of access.

The Subscription page does it in one step: pick an agent whose key this browser knows, and pay in one transaction.

Trial keys, old and new#

What a trial key used to be: a small balance that could be spent on anything, including running arbitrary WASI code at our expense.

What it is now: a grant, scoped to the curated connectors, so that the thing you can try for free is the thing we sell. Concretely:

• its value is an allowance, not a balance — granted by us, never withdrawable, and it ends at its expiry. A balance is the customer's money, and money does not expire;
• it is a grant: it cannot be withdrawn and cannot be used to pay a developer through X-Attached-Deposit, so it can only ever become compute and connector fees;
• it is scoped to the connector namespace and nothing else, so it cannot run arbitrary code on our account;
• it carries no wallet. A trial call gets no custody host functions: a connector that spends real balances is not a "try before you buy" operation.

One per wallet, claimable within a window after the wallet is created, valid for a number of days — all three are operator settings rather than constants, and the claim endpoint reports the exact values it granted. There is also a per-IP cap, which exists for the obvious reason.

The per-wallet connector quota#

Connector calls are also rate-limited per wallet, by a ladder that widens as the wallet gets older. The shipped ladder starts at 10 calls a day for a wallet in its first 24 hours, 50 after a day, and 500 after a week. Operators can change the ladder; the numbers live in the coordinator'sconnector_quota_tiers table.

The quota is independent of paying. It is not a feature a subscription unlocks and it is not something a subscription takes away: it exists so that one busy agent cannot exhaust the workers, and so that one abuser cannot ruin deliverability for everyone sharing a connector's reputation. A subscriber and a non-subscriber of the same wallet age get the same ladder.

What a subscription changes is how a call is paid for, not how many are allowed. What the quota changes is how many, not the price. They are two different questions and neither answer moved when the other was introduced.

What changed, plainly#

• Connectors now carry their prices on chain, per operation, and the contract charges the exact operation named in the request. Over-payment is returned; the caller pays the price, not what they attached.
• Connector authors are credited on chain, per operation, out of that price.
• A subscription is a new way to pay for those calls, bought for an AGENT's key. Everything that worked before — a funded payment key, paid per call — works exactly as it did.
• Trial keys are now scoped to connectors. Running arbitrary WASI is still available on a funded key, exactly as it always was; what changed is that we no longer fund it for you.