Local-first Open ledger Now launching

Your agent is thinking.
Sponsored credits the wait.

SAI puts one quiet sponsor line in your coding agent’s wait state and records sponsor-funded AI credits — spent straight back on model calls through a local, OpenAI‑compatible gateway. Your code never leaves the machine.

Install CLI Become a sponsor → no cloud account · sponsor-funded credits · one command to kill it

wallet 0.000 credits

sai · claude

09:41 EARN sponsor·build_cache +0.013 09:44 SPEND gateway·model_call 2.1k tok −0.009 09:52 EARN sponsor·trace_debug +0.011 10:07 EARN sponsor·secret_review +0.009 10:18 SPEND gateway·model_call 4.7k tok −0.014 10:26 EARN sponsor·build_cache +0.013 10:31 EARN sponsor·trace_debug +0.011 10:55 SPEND gateway·model_call 1.3k tok −0.005 11:02 EARN sponsor·secret_review +0.009 11:09 EARN sponsor·build_cache +0.013

§1

Install CLI

npm launcher · platform binary · no source checkout

$npm install -g @sponsoredai/cli

$sai login # local user + key, nothing uploaded

$sai claude # your agent, now with a wallet

§2

The loop closes on your AI bill

earn → hold → spend, all on your disk

01 · WRAP

Run the same agent command

Start with sai claude instead of claude. SAI opens a real terminal session around your agent and measures idle timing only — not prompts, code, or output.

No agent patches, no forks. Interactive terminals only; CI and headless runs are detected and left alone.

02 · WAIT

Quiet waits become cards

After 10 seconds with no terminal output, SAI can render one sponsor line at the bottom of the terminal. At most one card every 75 seconds — tune it or shut it off.

A spinner that keeps redrawing counts as output. A card earns credits only after it stays visible for at least 5 seconds.

03 · SPEND

Credits meter the gateway

Point any client at the local gateway (/v1/chat/completions) and local credits are deducted per token. Earned waiting, spent thinking.

Sponsor-funded credits are recorded locally, then spent through the gateway against metered model usage.

§3

What does waiting pay?

market bid split, not a guarantee

Your agent’s idle time

How long does your agent spend thinking, per day? Count the spinners, the test runs, the long diffs. If no paid sponsor campaign is available, the wait pays zero.

45 min / day of agent wait

Normal frequency: a card needs ≥10s of quiet and cards sit ≥75s apart. The market ranks funded campaigns by bid, then pays only qualified five-second placements.

payout / cardPROJECTED+0.012

cards / day36

developer credits / day60% NET+0.432

covers (tokens)6.5M in · 2.2M out / mo

+12.96 developer credits / month when funded

Projected at launch pricing while the live market loads from /v1/market.

Qualified clicks pay 50× the card rate on top of this — one click is worth a day of waits.

Current market loading /v1/market

Campaign	Status	Bid/block	Dev/QP	Dev/click	Remaining

§4

Never leaves this machine

the schema is the contract

~~prompts~~NEVER SENT
~~source code~~NEVER SENT
~~file paths~~NEVER SENT
~~terminal output~~NEVER SENT
~~shell history~~NEVER SENT
~~repository URLs~~NEVER SENT

The runner tracks when output happens, not what it says. An event is eleven boring fields, and anything outside the schema is stripped before it exists. Audit it yourself: sai privacy schema

KILL SWITCH One command hard‑stops every sponsor surface, with a reason on the record: sai config kill-switch on

// the ENTIRE payload of a sponsor event

{ "surface": "cli_agent_wait", "tool": "claude", "event": "agent_thinking", "duration_bucket": "10-30s", "terminal_interactive": true, "ci": false, "country": "PT", "code_uploaded": false, "prompt_uploaded": false, "logs_uploaded": false }

// the last three can never be true. it’s in the type.

§5

For sponsors: buy qualified wait-state inventory

Stripe checkout · paid placements

A developer watching an agent think is a sponsored moment with measurable qualified views.

Sponsors create campaigns, pay through Stripe Checkout, and buy blocks of 1,000 qualified five-second placements. After reserved infra cost, 60% of net sponsor spend becomes developer credits and 40% is platform revenue.

✓Qualified impressions only. A card renders after ≥10s of real agent wait, in an interactive terminal, never in CI.
✓No fatigue by design. Cards sit ≥75 seconds apart with a hard daily payout cap — scarcity is the format.
✓Clicks bill 50× the placement rate. You only pay the multiple on real intent — a click-through on an already-qualified card — and the developer earns the same 60% share of it.
✓Developers opt in knowingly, because the card pays them in sponsored credits. Goodwill is the product model.
✓Reporting follows the event schema. Rendered and qualified placements are recorded without prompts, code, logs, or terminal output.

What you buy, exactly

developer’s terminal · live

✦ thinking… 14s

+0.012 creditsYour Brand — Ship faster agent workflows yourcompany.com

✦ thinking…

That’s the unit: sponsor name, 3–80 characters of copy, a destination, and the developer payout visible before the card renders.

§6

Fair questions

So… this is adware?

It’s one line of text, in a moment you were staring at a spinner anyway, that pays you in AI credits. It only appears in interactive terminals, never in CI, at most every 75 seconds. You control frequency (sai config set frequency low), and sai config kill-switch on stops every sponsor surface instantly. Adware doesn’t ship a kill switch on the front page.

What is a credit actually worth?

Credits are the unit the local gateway meters at the repo defaults — 0.002 per 1k input tokens and 0.006 per 1k output tokens. Paid sponsor placements add the developer share of net spend to the wallet; model calls spend from the same ledger.

Can you read my code or prompts?

No, and not as a policy promise — as a mechanism. The runner watches output timing through a PTY, never content. Events are sanitized against a fixed schema where code_uploaded, prompt_uploaded and logs_uploaded are hard-coded false. Run sai privacy schema and read the whole contract.

Why credits instead of cash?

Credits directly offset model calls in the local gateway, so the reward stays inside the developer workflow. Sponsors pay for qualified attention; after reserved infra cost, the net spend is split 60% to developers and 40% to the platform.

What counts as an impression for sponsors?

A billable placement requires ≥10 seconds of agent wait, an interactive terminal, ≥75 seconds since the previous card, outside CI, and at least five seconds of visible time before qualification. A click-through on a qualified card bills the sponsor 50× the placement rate — at most one paid click per placement — and the developer earns the same 60% share of it.

Is any of this live today?

Sponsor checkout is open: sponsors fund campaigns through Stripe Checkout, and qualified wait-state placements credit the developer wallet whenever paid demand is available. Until the first campaign is funded, the figures on this page marked PROJECTED use launch pricing — the same rates the first sponsors buy at. The moment a campaign goes live, the page switches to real market numbers automatically.

Does it work offline? Does it phone home?

The wallet, the ledger, the dashboard and the gateway all live on 127.0.0.1. The CLI uploads nothing today; the sponsor event schema documents the only thing that ever could. The default gateway response is even a deterministic local mock until you point it at an upstream.

The spinner is sponsor inventory.
Qualified waits fund AI credits.

Install it from the repo, connect sponsor inventory, and watch qualified placements fund the local ledger.

Get SAI ↑ Become a sponsor Sign in with Google

∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗ ∗