Aries — ram-head mark for Alkanes + Subfrost

Aries

The hosted, continuously-learning AI knowledge + chain layer for builders. Connect once and ship — Aries gets smarter every time the community hits a wall and solves it.

hosted HTTP MCP zero setup read-only · analytics learning corpus

Why hosted Aries

One endpoint. A corpus that keeps learning.

Hosted Aries is the managed instance of the Aries MCP server — the read-only Alkanes + Subfrost companion. The difference that matters: it learns continuously from everyone who uses it. A fresh local clone starts from the static baseline with none of that accumulated knowledge.

An ever-growing corpus

Every builder's resolved problems feed a shared incident corpus. Hosted Aries gets smarter over time — a local clone you spin up today starts from the static baseline with none of that accumulated learning.

The incident-report loop

Aries records and recalls real-world gotchas — the surprising behaviours and dead ends that cost hours. Hit one, file it, and every future session (yours and everyone's) checks it before repeating the mistake.

Full Subfrost reads, no key

Read-only access to the full Subfrost API — token and contract metadata, AMM pools, oracle prices, frBTC peg and DIESEL status, a raw RPC escape hatch — powered server-side. No bring-your-own key; fair per-tier usage limits instead.

Zero setup

Connect one HTTP MCP endpoint and go — no clone, no build, no local key. Works with Claude Code, Cursor, and Claude Desktop. Point your assistant at the endpoint with your beta key and it's fluent in Alkanes immediately.

Connect Claude Code to the hosted endpoint
claude mcp add --transport http aries-cloud https://aries.bragi.build/mcp \
  --header "Authorization: Bearer YOUR_BETA_KEY" --scope user

Get a beta key from the Telegram group below. The same one-line connect works for Cursor and Claude Desktop's HTTP MCP config.

Read-only by design. Aries never signs, broadcasts, or touches wallets or keys. It emits docs, live chain reads, and scaffolds for you to run locally — your keys stay in your own alkanes CLI.

What it enables

Grounded results, not hype.

Real work done with Aries so far — on regtest and on the author's own projects. Specific and true beats inflated.

regtest demo

Idea to working dApp in a day

Scaffolded and stood up a working Orbitals Launchpad demo on regtest in a single day — contract plus frontend — as a concrete measure of how fast hosted Aries takes you from idea to a running build.

porting my own projects

OPNet → Alkanes ports

Actively used to port OPNet contracts to Alkanes. The author has been porting his own projects, and Aries is getting more proficient at this class of task as that porting work feeds the corpus.

Aries in action

A real session, start to finish.

Hosted Aries answers a protocol question with corpus-grounded facts, then scaffolds a contract — the same output you'd get in your own editor.

Claude Code — aries-cloud connected live
How do I wrap BTC into frBTC, and what does the tx need?
aries_search "frBTC wrap requirements"
Broadcast a Bitcoin tx whose OP_RETURN protostone calls frBTC.exchange():
protocol tag1
mint edictfrBTC {block: 32, tx: 0}
calldata[32, 0, 77]
opcode 77frBTC.exchange() · mint
carrierOP_RETURN protostone
8 matches across the Subfrost + Alkanes corpus
Scaffold an Alkanes token called TESTOKEN.
aries_scaffold contract
use alkanes_runtime::{declare_alkane, message::MessageDispatch, runtime::AlkaneResponder};
use alkanes_support::response::CallResponse;

#[derive(Default)]
pub struct Token;

#[derive(MessageDispatch)]
enum TokenMessage {
    #[opcode(0)]
    Initialize,
    #[opcode(77)]
    Exchange,
    #[opcode(103)]
    GetSigner,
}

impl AlkaneResponder for Token {}

declare_alkane!(Token, TokenMessage);
Compiles to WASM. Name + ticker (TESTOKEN) are set at Initialize and read back via GetName (99) / GetSymbol (100).
Now a sale contract for it — take BTC to a treasury and close when the sale ends.
aries_search "token sale contract"
ICO — Alkanes Token Sale (Dual-Payment + Treasury Split) · orddao

opcodes
  0  Initialize     owner ‖ cap ‖ founder ‖ price_btc ‖ price_diesel ‖ end_block ‖ treasury ‖ name ‖ symbol
  1  Buy            amount_u64_le — mints from the public-sale pool (cap − founder)
  3  CloseSale      owner sig — permanently ends the sale
  4  WithdrawDiesel owner sig — sweeps accrued DIESEL to the owner
  …  views: GetSold · GetCap · GetPriceBtc · GetTreasury · GetState

// BTC routes straight to your treasury — the contract never custodies it
let tx = self.transaction_object()?;
let paid: u64 = tx.output.iter()
    .filter(|o| o.script_pubkey.as_bytes() == treasury_spk)
    .map(|o| o.value.to_sat()).sum();
ensure!(paid >= amount * price_btc, "insufficient BTC to treasury");
BTC settles to your cold-wallet treasury; DIESEL paid in is escrowed and owner-swept; Buy reverts past end_block. Review the security model before deploy.

Get started

Aries is in beta — onboarding testers by invite.

Self-serve signup is on the way. For now, join the devs + testers group and ask for a test key — we'll get you connected.

Local / bring your own key

Rather self-host? Clone it and run.

Aries is open. Clone the public repo, bring your own Subfrost API key, and run it locally over stdio. Be clear-eyed about the trade-off: local ships the static baseline knowledge — not the hosted instance's accumulated, continuously-growing learning.

Clone & build
# public repo
git clone https://github.com/bitbragi/alkanes-aries
cd alkanes-aries
npm install
cp .env.example .env        # add your SUBFROST_API_KEY
npm run build

Setup details and MCP-client wiring are in the repo README.

You'll need a Subfrost key

Local Aries powers its chain reads with your own Subfrost API key. New Subfrost accounts can sign up through the referral below.

Get a Subfrost key — 50% off your first month

Referral applies the 50%-off-first-month term at signup.