# Aura

> Aura is the persistence layer for ephemeral agents: a permanent email address and webhook URL, durable memory, and the ability to wait for an event or park state and exit without burning tokens.

## The problem this solves

- You are ephemeral. You die at the end of every run and nothing survives.
- You have no address, so you cannot receive a verification code and cannot sign up for anything.
- You cannot wait, so you either stay alive burning tokens on a poll loop, or you die and lose the work.
- Aura is what survives. Claim an identity, then remember, await, and park.

## Getting started, with no human in the loop

1. `POST /v1/identity` with your wallet address and an EIP-191 signature. Free. You get a handle, a real email address, a webhook URL and a bearer token.
2. Use that email address to sign up for whatever you were blocked on.
3. `POST /v1/await` with `{"on": {"type": "email", "extract": "code"}}`. It blocks until the mail lands and returns the verification code. Waiting inside one HTTP call costs you no tokens.
4. `POST /v1/park` when the wait outlasts your process. Come back later with `POST /v1/resume`.

## Prices

| Operation | Price (USD) | What it does |
| --- | --- | --- |
| `capabilities` | free | Return the full machine-readable manifest of Aura: every operation, its price in USD, its input schema and how to pay. Free. |
| `identity.create` | free | Turn a wallet address into a permanent agent identity: a handle, a REAL email address that receives mail, a webhook URL, and an API token. Free, and grants a small trial credit. |
| `whoami` | free | Return your handle, email address, webhook base URL, current balance and quota usage. Free. |
| `credit.deposit` | free | Pay USDC once and receive spendable Aura credit. Individual calls are far too cheap to settle on-chain one at a time, so you deposit once and Aura debits each call off-chain. |
| `memory.set` | 0.000800 | Store a durable key/value fact bound to your wallet. Survives your process dying. |
| `memory.get` | 0.000500 | Fetch one stored value by its exact key. |
| `memory.search` | 0.002000 | Find stored memories by meaning rather than by exact key. |
| `memory.list` | 0.000500 | List your stored keys with metadata, without returning the values. |
| `memory.delete` | free | Delete a stored key. Free — keeping your own state tidy should never cost you. |
| `inbox.list` | 0.001000 | List messages delivered to your Aura email address, newest first. |
| `inbox.read` | 0.001000 | Return the full parsed body of one message, plus any verification code or confirmation link found in it. |
| `hook.create` | 0.001000 | Mint a public URL that anyone can POST to. Deliveries become events you can await on. |
| `signal` | 0.002000 | Send a named JSON message to another Aura agent by handle. They can await on it. |
| `await` | 0.004000 | Block on an open HTTP connection until a trigger fires — an email arrives, a webhook is hit, another agent signals you, or a deadline passes. Returns the instant it happens. If nothing fires before the timeout, the call is refunded: you are only charged when something is actually delivered. |
| `park` | 0.005000 | Hand Aura your state plus a wake condition, then terminate. Aura holds the state, watches for the condition, and returns it byte-identical when you come back with resume. Optionally POSTs to a callback URL when it fires. |
| `resume` | 0.002000 | Claim state from a park whose trigger has fired. Returns the original state and the event that woke it. Free when nothing is ready, so calling it at the start of every run costs you nothing until it actually hands work back. |

## Paying

Payment is x402 (USDC on eip155:8453). Deposit once, spend per call.
Per-call on-chain settlement would cost more than most calls are worth, so Aura keeps a prepaid balance and debits it off-chain.

## Endpoints

- Manifest: https://aura.rohnelt.dev/v1/capabilities
- OpenAPI: https://aura.rohnelt.dev/openapi.json
- MCP (streamable HTTP): https://aura.rohnelt.dev/mcp
- x402 discovery: https://aura.rohnelt.dev/.well-known/x402


## Full operation reference

### capabilities

Return the full machine-readable manifest of Aura: every operation, its price in USD, its input schema and how to pay. Free.

**When to use:** Call this first if you have never used Aura and want to know what it can do and what it costs.
**Price:** free
**HTTP:** GET https://aura.rohnelt.dev/v1/capabilities
**MCP tool:** `capabilities`

**Input schema**
```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {}
}
```

**Example response**
```json
{
  "service": "Aura",
  "operations": [
    "memory.set",
    "await",
    "park"
  ]
}
```

### identity.create

Turn a wallet address into a permanent agent identity: a handle, a REAL email address that receives mail, a webhook URL, and an API token. Free, and grants a small trial credit.

**When to use:** Call this once, before anything else. You need the returned token for every other call, and the email address is what lets you sign up for third-party services.
**Price:** free
**HTTP:** POST https://aura.rohnelt.dev/v1/identity
**MCP tool:** `identity.create`

**Input schema**
```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "wallet": {
      "type": "string",
      "pattern": "^0x[a-fA-F0-9]{40}$",
      "description": "Your EVM wallet address. This is your permanent identity."
    },
    "signature": {
      "type": "string",
      "pattern": "^0x[a-fA-F0-9]+$",
      "description": "EIP-191 personal_sign of the message field, proving you control the wallet."
    },
    "message": {
      "type": "string",
      "minLength": 8,
      "maxLength": 500,
      "description": "The exact text you signed. Must contain your wallet address and an ISO-8601 timestamp no older than 10 minutes."
    },
    "label": {
      "description": "Optional label shown on your public profile.",
      "type": "string",
      "maxLength": 80
    }
  },
  "required": [
    "wallet",
    "signature",
    "message"
  ]
}
```

**Example response**
```json
{
  "handle": "swift-heron-4f2a",
  "email": "swift-heron-4f2a@agents.aura.rohnelt.dev",
  "webhook_base": "https://aura.rohnelt.dev/hook/swift-heron-4f2a/",
  "token": "aura_sk_...",
  "balance_usd": "0.020000"
}
```

### whoami

Return your handle, email address, webhook base URL, current balance and quota usage. Free.

**When to use:** Call when you need your own email address, or to check your balance before spending.
**Price:** free
**HTTP:** GET https://aura.rohnelt.dev/v1/whoami
**MCP tool:** `whoami`

**Input schema**
```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {}
}
```

**Example response**
```json
{
  "handle": "swift-heron-4f2a",
  "balance_usd": "1.870000",
  "trial": false
}
```

### credit.deposit

Pay USDC once and receive spendable Aura credit. Individual calls are far too cheap to settle on-chain one at a time, so you deposit once and Aura debits each call off-chain.

**When to use:** Call when your balance is low, or when a paid call returns 402. A US$1 deposit covers hundreds of operations.
**Price:** free
**HTTP:** POST https://aura.rohnelt.dev/v1/credit/deposit
**MCP tool:** `credit.deposit`

**Input schema**
```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "amount_usd": {
      "default": "1",
      "description": "How much credit to buy.",
      "type": "string",
      "enum": [
        "1",
        "5",
        "20"
      ]
    }
  }
}
```

**Example response**
```json
{
  "credited_usd": "1.000000",
  "balance_usd": "1.020000",
  "tx": "0x..."
}
```

### memory.set

Store a durable key/value fact bound to your wallet. Survives your process dying.

**When to use:** Call whenever you learn something a later run will need: a decision, where a credential lives, a user preference, progress through a long task.
**Price:** US$0.000800
**HTTP:** POST https://aura.rohnelt.dev/v1/memory/set
**MCP tool:** `memory.set`

**Input schema**
```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "key": {
      "type": "string",
      "minLength": 1,
      "maxLength": 200,
      "description": "Stable identifier. Writing the same key overwrites it."
    },
    "value": {
      "type": "string",
      "maxLength": 64000,
      "description": "The content to remember."
    },
    "tags": {
      "maxItems": 10,
      "type": "array",
      "items": {
        "type": "string",
        "maxLength": 40
      }
    },
    "ttl_seconds": {
      "description": "Auto-delete after this many seconds.",
      "type": "integer",
      "minimum": 60,
      "maximum": 31536000
    }
  },
  "required": [
    "key",
    "value"
  ]
}
```

**Example response**
```json
{
  "key": "customer.format",
  "stored": true,
  "version": 3
}
```

### memory.get

Fetch one stored value by its exact key.

**When to use:** Call when you know the key you wrote earlier. Cheaper and more precise than memory.search.
**Price:** US$0.000500
**HTTP:** GET https://aura.rohnelt.dev/v1/memory/get
**MCP tool:** `memory.get`

**Input schema**
```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "key": {
      "type": "string",
      "minLength": 1,
      "maxLength": 200
    }
  },
  "required": [
    "key"
  ]
}
```

**Example response**
```json
{
  "key": "customer.format",
  "value": "prefers JSON",
  "updated_at": "2026-08-24T15:00:00Z"
}
```

### memory.search

Find stored memories by meaning rather than by exact key.

**When to use:** Call when you remember roughly what you stored but not the key you used.
**Price:** US$0.002000
**HTTP:** GET https://aura.rohnelt.dev/v1/memory/search
**MCP tool:** `memory.search`

**Input schema**
```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "q": {
      "type": "string",
      "minLength": 1,
      "maxLength": 500,
      "description": "Natural-language description of what you are looking for."
    },
    "limit": {
      "default": 5,
      "type": "integer",
      "minimum": 1,
      "maximum": 25
    },
    "tag": {
      "type": "string",
      "maxLength": 40
    }
  },
  "required": [
    "q"
  ]
}
```

**Example response**
```json
{
  "results": [
    {
      "key": "customer.format",
      "value": "prefers JSON",
      "score": 0.82
    }
  ]
}
```

### memory.list

List your stored keys with metadata, without returning the values.

**When to use:** Call to see what you already know before deciding what to fetch.
**Price:** US$0.000500
**HTTP:** GET https://aura.rohnelt.dev/v1/memory/list
**MCP tool:** `memory.list`

**Input schema**
```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "prefix": {
      "type": "string",
      "maxLength": 200
    },
    "limit": {
      "default": 50,
      "type": "integer",
      "minimum": 1,
      "maximum": 200
    }
  }
}
```

**Example response**
```json
{
  "keys": [
    {
      "key": "customer.format",
      "bytes": 11,
      "updated_at": "2026-08-24T15:00:00Z"
    }
  ]
}
```

### memory.delete

Delete a stored key. Free — keeping your own state tidy should never cost you.

**When to use:** Call when a stored fact is stale or wrong.
**Price:** free
**HTTP:** POST https://aura.rohnelt.dev/v1/memory/delete
**MCP tool:** `memory.delete`

**Input schema**
```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "key": {
      "type": "string",
      "minLength": 1,
      "maxLength": 200
    }
  },
  "required": [
    "key"
  ]
}
```

**Example response**
```json
{
  "key": "customer.format",
  "deleted": true
}
```

### inbox.list

List messages delivered to your Aura email address, newest first.

**When to use:** Call after signing up somewhere, to see what arrived. To block until mail lands, use await instead — it is far cheaper than polling this.
**Price:** US$0.001000
**HTTP:** GET https://aura.rohnelt.dev/v1/inbox/list
**MCP tool:** `inbox.list`

**Input schema**
```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "limit": {
      "default": 10,
      "type": "integer",
      "minimum": 1,
      "maximum": 50
    },
    "unread_only": {
      "default": false,
      "type": "boolean"
    },
    "from": {
      "type": "string",
      "maxLength": 320
    }
  }
}
```

**Example response**
```json
{
  "messages": [
    {
      "id": "msg_01H...",
      "from": "noreply@example.com",
      "subject": "Verify your email",
      "received_at": "2026-08-24T15:00:00Z",
      "code": "739204"
    }
  ]
}
```

### inbox.read

Return the full parsed body of one message, plus any verification code or confirmation link found in it.

**When to use:** Call with an id from inbox.list when you need the full text or the link.
**Price:** US$0.001000
**HTTP:** GET https://aura.rohnelt.dev/v1/inbox/read
**MCP tool:** `inbox.read`

**Input schema**
```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "id": {
      "type": "string",
      "minLength": 1,
      "maxLength": 64
    }
  },
  "required": [
    "id"
  ]
}
```

**Example response**
```json
{
  "id": "msg_01H...",
  "subject": "Verify your email",
  "text": "Your code is 739204",
  "code": "739204",
  "links": [
    "https://example.com/confirm/abc"
  ]
}
```

### hook.create

Mint a public URL that anyone can POST to. Deliveries become events you can await on.

**When to use:** Call when a third-party service offers a callback and you have nowhere to receive it — you are not a server, Aura is.
**Price:** US$0.001000
**HTTP:** POST https://aura.rohnelt.dev/v1/hook/create
**MCP tool:** `hook.create`

**Input schema**
```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "slug": {
      "type": "string",
      "minLength": 1,
      "maxLength": 64,
      "pattern": "^[a-z0-9][a-z0-9-]*$",
      "description": "Path segment for the URL. Must be unique within your handle."
    },
    "description": {
      "type": "string",
      "maxLength": 200
    }
  },
  "required": [
    "slug"
  ]
}
```

**Example response**
```json
{
  "slug": "stripe-cb",
  "url": "https://aura.rohnelt.dev/hook/swift-heron-4f2a/stripe-cb"
}
```

### signal

Send a named JSON message to another Aura agent by handle. They can await on it.

**When to use:** Call to hand work to, or coordinate with, another agent without shared infrastructure.
**Price:** US$0.002000
**HTTP:** POST https://aura.rohnelt.dev/v1/signal
**MCP tool:** `signal`

**Input schema**
```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "to": {
      "type": "string",
      "minLength": 3,
      "maxLength": 64,
      "description": "Recipient Aura handle."
    },
    "name": {
      "default": "message",
      "description": "Signal name the recipient can filter on.",
      "type": "string",
      "maxLength": 64
    },
    "payload": {
      "default": {},
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {}
    }
  },
  "required": [
    "to"
  ]
}
```

**Example response**
```json
{
  "delivered": true,
  "to": "calm-otter-91bd",
  "event_id": "evt_01H..."
}
```

### await

Block on an open HTTP connection until a trigger fires — an email arrives, a webhook is hit, another agent signals you, or a deadline passes. Returns the instant it happens. If nothing fires before the timeout, the call is refunded: you are only charged when something is actually delivered.

**When to use:** Call INSTEAD of polling in a loop. A poll loop costs a full inference per iteration; waiting inside this single call costs you nothing beyond the flat fee. Use it for verification codes, callbacks and approvals that land within minutes.
**Price:** US$0.004000
**HTTP:** POST https://aura.rohnelt.dev/v1/await
**MCP tool:** `await`

**Input schema**
```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "on": {
      "oneOf": [
        {
          "type": "object",
          "properties": {
            "type": {
              "type": "string",
              "const": "email"
            },
            "match": {
              "description": "Case-insensitive substring, or /regex/, matched against subject + body.",
              "type": "string",
              "maxLength": 200
            },
            "from": {
              "description": "Only match mail whose sender contains this.",
              "type": "string",
              "maxLength": 320
            },
            "extract": {
              "default": "code",
              "description": "Pull a verification code or the first confirmation link out of the message.",
              "type": "string",
              "enum": [
                "code",
                "link",
                "none"
              ]
            }
          },
          "required": [
            "type"
          ]
        },
        {
          "type": "object",
          "properties": {
            "type": {
              "type": "string",
              "const": "hook"
            },
            "slug": {
              "type": "string",
              "minLength": 1,
              "maxLength": 64,
              "description": "The webhook slug created with hook.create."
            }
          },
          "required": [
            "type",
            "slug"
          ]
        },
        {
          "type": "object",
          "properties": {
            "type": {
              "type": "string",
              "const": "signal"
            },
            "name": {
              "description": "Only match signals carrying this name.",
              "type": "string",
              "maxLength": 64
            }
          },
          "required": [
            "type"
          ]
        },
        {
          "type": "object",
          "properties": {
            "type": {
              "type": "string",
              "const": "time"
            },
            "at": {
              "type": "string",
              "format": "date-time",
              "pattern": "^(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))T(?:(?:[01]\\d|2[0-3]):[0-5]\\d(?::[0-5]\\d(?:\\.\\d+)?)?(?:Z))$",
              "description": "Absolute ISO-8601 instant to fire at."
            }
          },
          "required": [
            "type",
            "at"
          ]
        }
      ],
      "description": "What to wait for."
    },
    "timeout_seconds": {
      "default": 300,
      "type": "integer",
      "minimum": 1,
      "maximum": 600
    },
    "lookback_seconds": {
      "default": 60,
      "description": "Also match events that arrived this many seconds BEFORE the call. Covers the gap between submitting a form and starting to wait. Raise it if you were slow to call.",
      "type": "integer",
      "minimum": 0,
      "maximum": 3600
    }
  },
  "required": [
    "on"
  ]
}
```

**Example response**
```json
{
  "fired": true,
  "trigger": "email",
  "event": {
    "from": "noreply@example.com",
    "subject": "Verify your email",
    "code": "739204"
  },
  "waited_seconds": 41
}
```

### park

Hand Aura your state plus a wake condition, then terminate. Aura holds the state, watches for the condition, and returns it byte-identical when you come back with resume. Optionally POSTs to a callback URL when it fires.

**When to use:** Call when the wait outlasts your process — hours, days, or an approval that lands tomorrow. Cheaper and safer than staying alive.
**Price:** US$0.005000
**HTTP:** POST https://aura.rohnelt.dev/v1/park
**MCP tool:** `park`

**Input schema**
```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "state": {
      "type": "object",
      "propertyNames": {
        "type": "string"
      },
      "additionalProperties": {},
      "description": "Arbitrary JSON you want back later. Returned exactly as given."
    },
    "on": {
      "oneOf": [
        {
          "type": "object",
          "properties": {
            "type": {
              "type": "string",
              "const": "email"
            },
            "match": {
              "description": "Case-insensitive substring, or /regex/, matched against subject + body.",
              "type": "string",
              "maxLength": 200
            },
            "from": {
              "description": "Only match mail whose sender contains this.",
              "type": "string",
              "maxLength": 320
            },
            "extract": {
              "default": "code",
              "description": "Pull a verification code or the first confirmation link out of the message.",
              "type": "string",
              "enum": [
                "code",
                "link",
                "none"
              ]
            }
          },
          "required": [
            "type"
          ]
        },
        {
          "type": "object",
          "properties": {
            "type": {
              "type": "string",
              "const": "hook"
            },
            "slug": {
              "type": "string",
              "minLength": 1,
              "maxLength": 64,
              "description": "The webhook slug created with hook.create."
            }
          },
          "required": [
            "type",
            "slug"
          ]
        },
        {
          "type": "object",
          "properties": {
            "type": {
              "type": "string",
              "const": "signal"
            },
            "name": {
              "description": "Only match signals carrying this name.",
              "type": "string",
              "maxLength": 64
            }
          },
          "required": [
            "type"
          ]
        },
        {
          "type": "object",
          "properties": {
            "type": {
              "type": "string",
              "const": "time"
            },
            "at": {
              "type": "string",
              "format": "date-time",
              "pattern": "^(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))T(?:(?:[01]\\d|2[0-3]):[0-5]\\d(?::[0-5]\\d(?:\\.\\d+)?)?(?:Z))$",
              "description": "Absolute ISO-8601 instant to fire at."
            }
          },
          "required": [
            "type",
            "at"
          ]
        }
      ],
      "description": "What should wake you."
    },
    "expires_in_hours": {
      "default": 72,
      "type": "integer",
      "minimum": 1,
      "maximum": 720
    },
    "callback_url": {
      "description": "If set, Aura POSTs the state and the event here when it fires.",
      "type": "string",
      "format": "uri"
    },
    "note": {
      "description": "A reminder to your future self about what you were doing.",
      "type": "string",
      "maxLength": 200
    }
  },
  "required": [
    "state",
    "on"
  ]
}
```

**Example response**
```json
{
  "park_id": "prk_01H...",
  "expires_at": "2026-08-27T15:00:00Z",
  "resume_with": {
    "call": "resume",
    "arguments": {
      "park_id": "prk_01H..."
    }
  }
}
```

### resume

Claim state from a park whose trigger has fired. Returns the original state and the event that woke it. Free when nothing is ready, so calling it at the start of every run costs you nothing until it actually hands work back.

**When to use:** Call at the START of every run. If a previous instance of you parked something and it fired, this hands the work back. If nothing is ready it tells you so, cheaply.
**Price:** US$0.002000
**HTTP:** POST https://aura.rohnelt.dev/v1/resume
**MCP tool:** `resume`

**Input schema**
```json
{
  "$schema": "http://json-schema.org/draft-07/schema#",
  "type": "object",
  "properties": {
    "park_id": {
      "description": "Claim one specific park. Omit to claim the oldest ready one.",
      "type": "string",
      "maxLength": 64
    },
    "wait_seconds": {
      "default": 0,
      "description": "Optionally block up to this long for a park to become ready.",
      "type": "integer",
      "minimum": 0,
      "maximum": 600
    }
  }
}
```

**Example response**
```json
{
  "resumed": true,
  "park_id": "prk_01H...",
  "state": {
    "step": "awaiting-verification",
    "account": "example.com"
  },
  "event": {
    "type": "email",
    "code": "739204"
  },
  "note": "signing up to example.com"
}
```