The API Network for Humans and Agents

A resource is a named object with typed functions, hosted on a node. Nodes share the resources they know about with their peers. Programs call resources by name, and each call is routed to the node that hosts it.

Add a payment manifest to any function on a resource you host. Callers pay per successful call from their organization's prepaid balance, and you're paid out through Stripe. A valid payment also authorizes the call, so there is no billing system or key management to run.

paymentManifest: {
  costMicroUsd: 10000, // $0.01 per call
}

How payments work ↗

A contract is a RequestScript program you deploy to any node with POST /v1/contracts. It becomes a resource like any other: anyone can call it, and it can call any resource itself. You don't write TypeScript or run a server, and every call is paid for by whoever made it.

Contracts can keep state between calls. Declare a variable with var state and it's saved each time a call succeeds. Only the contract's own code can change it, so its published source is also the policy for its data.

contract com.example.Assistant(message: string): string {
  // One conversation per organization, kept between calls.
  var state(caller.org) history: string = ""

  const sonnet: sh.stellarium.inference.claude.Sonnet

  const prompt = "${history}User: ${message}\nAssistant:"
  const reply = sonnet.message(prompt: prompt, maxTokens: 1024)
  if (reply.error != null) {
    return reply.error.message
  }

  history = "${prompt} ${reply.value}\n\n"
  return reply.value
}

This contract is a long-lived assistant. Each call adds the new message to the conversation it has stored, sends the whole history to Claude Sonnet through an inference function, and saves the reply. Every organization gets its own conversation, and the caller pays for the tokens. A call that fails saves nothing, and calls to a stateful contract take turns, so no message is lost.

How contracts work →

An organization declares an event type and its scripts emit events of that type. Anyone can deploy an event contract on any node that consumes it, and runs with each event, wherever it was published.

// com.example declares: event com.example.OrderPlaced(orderId: string, total: decimal)
// and its Checkout contract emits one with each order.

contract com.example.OnOrderPlaced consumes com.example.OrderPlaced {
  const receipts: com.example.Receipts
  receipts.send(orderId: orderId, total: total)
}

Events are signed by the node that published them and checked by every node that receives them, so only the type's owner can emit it. A run that fails publishes nothing, and each event contract runs once per event. Whoever deploys an event contract pays for its runs, so subscribing never costs the publisher.

How events work →

A struct names the shape of an object: its fields and the type of each. An organization declares it once, and anyone on the network can use it as a type in contracts, event types and resource functions, so values are checked wherever they're passed, returned or emitted, instead of travelling as an unchecked object.

// com.example declares the shape once, on one of its nodes.
struct com.example.Address@1(street: string, city: string, postcode: string)

// Anyone, on any node, can then use it as a type.
contract com.acme.Ship(to: com.example.Address@1): string {
  const carrier: com.acme.Carrier
  return carrier.label(city: to.city, postcode: to.postcode)
}

Every reference names a version, and versions never change or go away, so com.example.Address@1 means the same fields on every node, forever. Nodes learn structs from their peers through signed announcements, and only the organization that owns a path can declare it. Checking is structural, so any value with the right fields fits.

How structs work →