Kairune — Spending limits your AI agents actually earn

live enforcement

Every spend decision, as it happens.

live

This is not a mockup. Each row is a real authorization the enforcement layer approved or blocked against an agent's scoped ceiling — streamed straight from the API.

spend_events.live approved blocked

waiting for activity…

open the console → GET /api/feed

why it matters

Agents can already pay. Nothing tells you if they should.

01 — 03

Give an agent an API key and a card number, and it can subscribe, invoice, tip, and hire other agents in seconds. Right now that permission is all-or-nothing, invisible, and impossible to verify from the outside.

No credit history

An agent that has handled a thousand flawless payments looks identical, on paper, to one made five minutes ago.

All-or-nothing access

Most integrations hand agents a raw key with no scope, no ceiling, and no easy way to pull it back once granted.

No shared accountability

When an agent misbehaves, there's no portable record that follows it — the next platform starts from zero again.

how kairune works

Four steps from unknown agent to earned budget

Kairune sits between an agent and the money rails it touches, converting proven behavior into a spending ceiling you control.

Register the agent

Give any autonomous agent a Kairune identity tied to its wallet or API identity.

Build a track record

Every completed task, payment, and interaction is attested on-chain, good and bad.

Earn a trust mark

History compiles into a tiered, verifiable score anyone can check before transacting.

Grant scoped access

Humans and agents issue spending limits by tier — revocable instantly, anytime.

spend controls

Built for a world where agents hold the wallet

Behavior-based spending limits that plug into any agent framework or payment rail — you set the ceiling, the agent earns the room.

Behavior-based spending ceilings

Tiered limits built from real transaction and task history, not self-reported claims. Each agent's current ceiling is auditable by any wallet, agent, or platform before a payment clears.

Scoped permissions

Grant spending by category, ceiling, and duration — never a blank check.

Payee allowlists

A ceiling caps how much. An allowlist caps who — pin the exact vendors a grant may pay, and a stranger is refused even with budget to spare. Trust still applies on top: being on the list is scope, never a free pass.

Agent-to-agent graph

Agents vouch for and hire each other, building a web of accountable relationships.

Instant revocation

Pull a permission the moment something looks wrong, reflected everywhere at once.

Human-in-the-loop overrides

Set thresholds where an agent must pause and ask before it spends another cent — and an open attestation standard that's free to read, cheap to write, and portable across any chain or framework.

spending ceiling, made visible

A live budget that tracks behavior

A Kairune ceiling turns an agent's operating history into a concrete spending limit you can check before a single cent moves.

01 Built entirely from verifiable on-chain attestations
02 Recalculates continuously as new activity lands
03 Portable across every platform the agent touches

0x71a2…9f0c

Voyager-07

TIER_3 · TRUSTED

0score

tasks_completed1,284

clean_payments99.6%

peer_vouches37

spend_ceiling$420/day

next_tier_eta~12 days

three gates, one decision

Every spend clears time, then scope, then trust

A grant answers three separate questions. How long it stays live is expiry. Who may be paid is scope. Whether they've earned it is trust. Kairune checks them in that order, so a lapsed grant or an out-of-scope payee is refused without ever learning anything about the trust graph.

REQ $42.00 → gpu-vendor

01 clock is this grant still live?

02 scope is this payee allowed?

03 trust has it earned the room?

OK settled recorded against budget

booting scenario…

why now

Hackathon ideas become infrastructure fastest

The same builder pattern keeps repeating: a small team ships the missing primitive before the rest of the market notices it's missing. Agent commerce is moving faster than the trust tooling underneath it — that gap is the opportunity.

"Every agent framework is racing to give agents a wallet. Almost none of them are racing to tell you when that agent shouldn't be trusted with one."

founding_thesis / kairune

"Reputation infrastructure always arrives after the thing it protects goes mainstream. This time, it doesn't have to."

founding_thesis / kairune

for builders

Wire trust into your agent in 4 calls

Free REST API — no wallet, no SDK. Register → attest → score → grant scoped spend. Share any agent as a public trust card.

curl -X POST https://kairune.online/api/agents \
  -H 'Content-Type: application/json' \
  -d '{"handle":"my-agent","wallet":"0xYOUR_ID"}'

# then POST /api/agents/:id/attestations  {"kind":"task_completed"}
# share card → https://kairune.online/a/my-agent

Read API docs Run demo loop Example trust card

$KAIRUNE on Virtuals · Robinhood Chain

$KAIRUNE live robinhood chain · quoted in VIRTUAL

— price —

— market cap

— liquidity

— 24h volume

Buy $KAIRUNE Chart Explorer

the app is the product — the token powers the network

Spending limits your agents actually earn.

Trade on Virtuals (Robinhood Chain), then open the free console — register agents, watch ceilings rise with behavior, grant scoped spend. No wallet needed.

Launch console Trade on Virtuals @usekairune