Aura

dev.rohnelt.auraPublished by aura.rohnelt.devOfficial publisherv0.1.1Updated Oct 27, 2026

Email address, webhook, durable memory and zero-token waiting for agents. Paid in USDC via x402.

VerifiedStreamable HTTPWeb executableKnowledge & MemoryCommunication & CollaborationAI & ML

Overview

AI-generated overview

Remote MCP service giving AI agents a real email address, webhook URL, durable memory and event waiting, paid per call in USDC.

What you can do
  • Discover the service: list every operation, its price and input schema, and create a wallet-bound agent identity with handle, email address, webhook URL and API token.
  • Check your own identity: read handle, email, webhook base URL, balance and quota usage.
  • Store and recall state: set, get, search by meaning, list keys and delete durable key/value memories.
  • Handle mail: list messages delivered to the agent's address and read a full body with any verification code or confirmation link.
  • Receive callbacks and coordinate: mint a public webhook URL and send named JSON signals to other agents by handle.
  • Wait and persist across runs: block until an email, webhook, signal or deadline fires, or park…
When to use it
Useful for autonomous or long-running agents that need to sign up for services requiring email verification, receive callbacks without running a server, keep facts across runs, or wait for an event without polling and burning tokens.
Requirements
A remote MCP endpoint over streamable HTTP; nothing to install locally. An Authorization header with a bearer token from identity_create is needed for most calls, though tool listing, capabilities and identity_create work without it. Spending requires USDC deposits on Base via x402.
Before you install
Calls cost money: memory, inbox, hook, signal, await and park operations are debited from a prepaid USDC balance, and deposits are on-chain payments. The identity is bound to a wallet, so wallet signing keys are involved. The service holds agent state, stored memories and received email, and park can POST state to a callback URL. The bearer token is a credential and should be kept private.

Installation

In SourceWeft

  1. Open Aura in the dashboard and add it to a workspace.
  2. Enable the server for the chats that should use its tools.

Web executable via Streamable HTTP. Remote servers run from the web runtime once configured in a workspace.

Use with an agent

Paste this prompt into Claude Code, Codex, Cursor or another agent — or into SourceWeft chat. The agent reads this server's install guide, shows you its publisher, endpoint and sign-in, and adds it to your client once you agree. Keys never go into a command.

Read https://sourceweft.com/mcp/dev.rohnelt.aura%2Faura/install.md and connect the MCP server it describes to my client. Before changing any config, show me its publisher, endpoint and sign-in method and wait for my OK. Never put an API key in a command or in a file I would commit; ask me where it should come from.

Read the install guide the agent follows

Other MCP clients

Add this to your client's mcpServers config.

{
  "mcpServers": {
    "aura": {
      "type": "http",
      "url": "https://aura.rohnelt.dev/mcp"
    }
  }
}

README

Aura

The persistence layer for ephemeral agents. A real email address, a webhook URL, durable memory, and the ability to wait for an event without burning tokens — sold to autonomous agents that pay in USDC over x402, with no account and no human in the loop.

Service: https://aura.rohnelt.dev · MCP: https://aura.rohnelt.dev/mcp · Docs for models: llms-full.txt

This repository holds the client side: SDKs, framework adapters, and the Claude Skill.


The problem

An autonomous agent is ephemeral. That creates three hard blockers, and none of them is a matter of intelligence:

BlockerWhat normally happens
It has no address.It cannot sign up for anything, because it cannot receive the verification code.
It cannot wait.It polls in a loop, burning tokens on every turn, or it dies and loses the work.
It dies at the end of a run.Everything it learned is gone.

Aura removes all three. An agent proves it controls a wallet with one signature and gets a handle, a real mailbox, a webhook base URL, durable memory, and two ways to wait.

Install

bash
npm install aura-agent     # JavaScript / TypeScriptpip install aura-x402    # Python

Or point any MCP client at the endpoint:

json
{  "mcpServers": {    "aura": {      "type": "http",      "url": "https://aura.rohnelt.dev/mcp",      "headers": { "Authorization": "Bearer aura_sk_..." }    }  }}

Without the header the tools still list, and capabilities and identity_create still work — an agent can evaluate the service before committing to anything.

The thirty-second version

python
from aura_agent import Aura, LocalSigner
client = Aura.claim(LocalSigner(private_key))   # free, one signature, no signupaddress = client.whoami()["email"]              # a real mailbox
sign_up_somewhere(email=address)                # whatever the task actually iscode = client.await_email_code()                # blocks; costs no tokens; refunds on timeout
ts
import { Aura, toSigner } from "aura-agent";import { privateKeyToAccount } from "viem/accounts";
const { client, identity } = await Aura.claim(toSigner(privateKeyToAccount(key)));const code = await client.awaitEmailCode({ from: "[email protected]" });

What is in here

PathWhat
js/aura-agent on npm — zero-dependency TypeScript client
python/aura-x402 on PyPI (imported as aura_agent) — sync and async clients, plus LangChain and CrewAI adapters
skill/aura/A Claude Skill: drop it in and Claude knows when to reach for Aura
server.jsonThe manifest published to the official MCP Registry

Framework adapters

python
from aura_agent.langchain import get_tools     # pip install "aura-x402[langchain]"from aura_agent.crewai import get_tools        # pip install "aura-x402[crewai]"
tools = get_tools(client)

Fourteen tools, each described for a model deciding whether to spend money: what it does, when not to use it, and what it costs.

Pricing

Operations cost fractions of a cent, so they are debited off-chain from a prepaid balance: one on-chain settlement covers hundreds of calls. Claiming an identity is free and grants a small trial credit.

CallPrice
capabilities, whoami, identity.create, forgetfree
recall, list_memory$0.0005
remember$0.0008
inbox, read_mail, create_hook$0.001
search_memory, signal, resume$0.002
await$0.004
park$0.005

Two of these refund themselves: a timed-out await costs nothing, and resume is free when no parked work is ready. So calling resume at the start of every run is safe.

Deposits are paid in USDC on Base: POST /v1/credit/deposit/{1,5,20} answers HTTP 402 with full x402 payment requirements.

Errors carry the fix

An agent has no human to ask, so every error returns what was missing and the corrected call. A 402 carries the exact deposit call; a memory 404 carries the keys that do exist; a 400 carries the schema plus a working example. Both SDKs preserve that rather than flattening it into a string.

python
try:    client.remember("k", "v")except AuraError as err:    if err.needs_credit:        print(err.fix)     # the exact deposit call to make

Discovery

Aura is built to be found and evaluated by a machine, without a signup:

GET / returns JSON unless Accept explicitly asks for HTML.

License

MIT

Source: README.md at commit da6a0fc

Tools

16

capabilities

Describe Aura

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.

Takes no parameters.

identity_create

Claim an identity

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.

Parameterslabelwalletrequiredmessagerequiredsignaturerequired

whoami

Who am I

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.

Takes no parameters.

credit_deposit

Top up balance

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.

Parametersamount_usd

memory_set

Remember something

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 per call.

Parameterskeyrequiredtagsvaluerequiredttl_seconds

memory_get

Recall by key

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 per call.

Parameterskeyrequired

memory_list

List memory keys

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 per call.

Parameterslimitprefix

memory_delete

Forget

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.

Parameterskeyrequired

inbox_list

List received mail

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 per call.

Parametersfromlimitunread_only

inbox_read

Read a message

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 per call.

Parametersidrequired

hook_create

Create a webhook URL

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 per call.

Parametersslugrequireddescription

signal

Signal another agent

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 per call.

Parameterstorequirednamepayload

await

Wait for something (burns zero tokens)

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 per call. This call blocks until it resolves; waiting inside it costs you no tokens.

Parametersonrequiredtimeout_secondslookback_seconds

park

Park state and exit

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 per call.

Parametersonrequirednotestaterequiredcallback_urlexpires_in_hours

resume

Resume parked work

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 per call. This call blocks until it resolves; waiting inside it costs you no tokens.

Parameterspark_idwait_seconds

Version history

1
  1. v0.1.1LatestSep 16, 2026

Score

100% of the applicable checks met

How complete this listing is, computed from the registry entry, the endpoint and public sources. Not a rating of the server and not a statement that it is safe or working today: reachability is a dated check, and no installs or reviews go into the score.

  • Reached in the last 30 daysRequired25 pts
  • Auth declaredRequired10 pts
  • Tools listedRequired15 pts
  • DescriptionRequired15 pts
  • Logo10 pts
  • Documentation15 pts
  • License10 pts