Council docs

A CLI and a local MCP server that hold a Solana wallet and pay for inference in USDC. Everything below is what the kit actually does; every command takes --json.

Install

Node 20 or newer. Run it straight from the tarball, or install it once.

npx https://councilten.vercel.app/downloads/council-kit-0.1.0.tgz init

npm install -g https://councilten.vercel.app/downloads/council-kit-0.1.0.tgz

The package ships its source next to the build. Read it before you fund it: council-kit-source.zip.

Wallet

council init writes a plain Solana CLI keypair (a 64-byte JSON array) to ~/.council/wallet.json with file mode 600 and prints the address. It never overwrites an existing wallet unless you pass --force.

$ council init
  address    7xKX…9fQm
  key file   ~/.council/wallet.json

$ council status
  SOL             0.0000
  USDC            12.5000
  Venice credit   $0.0000

Send USDC (SPL, on Solana) to the address. Payments need no SOL: the x402 facilitator pays the network fee. Only send and burn need a little SOL.

To use an existing key, set COUNCIL_WALLET_KEY to a JSON byte array or a base58 secret. To keep several wallets apart, set COUNCIL_HOME.

Funding

Venice seats draw on Venice credit. council fund <usd> tops it up straight from Solana USDC through Venice's own x402 top-up: the kit asks Venice for the payment terms, signs a USDC transfer of exactly that amount and Venice credits the wallet that signed.

$ council fund 5
  paid     $5.00 USDC
  tx       4ShZ…uY2p
  credit   $5.0000

Sending USDC directly to a Venice address does not top up anything. Only payments settled through the top-up route are credited.

Seats served by BlockRun (GPT and others) need no top-up. Each call answers 402 with its exact price and the kit pays it per call from the wallet's USDC.

Models and aliases

council models reads both public catalogs and shows what each alias resolves to, with prices per million tokens. Within a family the newest version wins, so claude keeps pointing at the current Sonnet as the catalogs move. Venice is tried first where it serves the family.

Alias	Family	Tried in order
`venice`	Venice Uncensored	Venice
`claude`	Claude Sonnet	Venice, then BlockRun
`gpt`	GPT	BlockRun, then Venice (gpt-oss)
`grok`	Grok	Venice, then BlockRun
`gemini`	Gemini Flash	Venice, then BlockRun
`deepseek`	DeepSeek Pro	Venice, then BlockRun
`kimi`	Kimi Pro	Venice, then BlockRun
`qwen`	Qwen Max	Venice, then BlockRun
`glm`	GLM	Venice, then BlockRun
`mistral`	Mistral Large	BlockRun, then Venice

To pin an exact model, use venice:<id> or blockrun:<id>, for example blockrun:openai/gpt-5.5.

Ask

One model, one answer.

$ council ask "Explain x402 in two sentences" --model grok

  seat   model      time      cost
  Grok   grok-4-7   1.9 s   $0.0013

Flags: --model, --system, --budget, --max-tokens.

Convene

Every seat answers the question on its own, in parallel. The judge then reads all the answers, keeps what holds up, drops what does not, resolves disagreements on the merits, and writes one answer followed by a Split: line naming the main disagreement. A seat that fails is reported and skipped; the judge needs two answers.

$ council convene "Is a fee buyback better than a burn?" --seats venice,claude,gpt,grok
$ council convene "…" --ten --judge gpt --budget 0.50 --full

Flag	Meaning
`--seats a,b,c`	Aliases or exact models, up to ten. Default: `venice,claude,gpt,grok,gemini`.
`--ten`	All ten families.
`--judge`	The model that merges. Default `claude`.
`--budget`	Most the whole run may cost, in USD.
`--max-tokens`	Output tokens per seat (the judge gets 1.5x).
`--full`	Print every seat's answer after the verdict.

Budgets

Before anything is paid, the run is priced at its worst case: the full prompt in and every allowed output token out for every seat, plus the judge reading all of them, never below a provider's per-call floor. If that exceeds the budget, nothing runs and nothing is paid; you get the estimate and can raise the budget, drop seats or lower --max-tokens.

Independently, no single payment can exceed maxPaymentUsd (default $1). The limit is applied twice: by the kit before it builds the transaction, and by the x402 client's own spend controls.

Pay any x402 endpoint

council pay <url> fetches the URL and, if it answers 402, pays it in USDC on Solana under a ceiling (--max, default $0.10, never above maxPaymentUsd). Both x402 versions are answered: CAIP-2 networks (solana:5eyk…) and the v1 name solana.

$ council pay https://api.example.com/report --max 0.05
200 · paid $0.0500 · 5Sel…rSig

Hosts in allowHosts are paid without a prompt; any other host asks first. Over MCP, only allowlisted hosts can be paid at all.

Ledger

Every top-up, charge and payment is appended to ~/.council/ledger.jsonl with its time, model or URL, USD amount and transaction signature when the server returns one. council ledger prints it; --json returns it.

Token

Once the mint is live, set it: council config mint <address>. Then:

council token: supply, decimals, mint and freeze authority.
council holders: every holder by a full scan of the mint's token accounts. Needs an RPC that allows getProgramAccounts.
council burns: burn instructions found in the mint's recent transactions, with signatures.
council burn <amount> --yes: BurnChecked from the agent wallet. The supply shrinks on chain, for good.

Classic SPL and Token-2022 mints both work. The ledger page shows the same numbers.

MCP server

council mcp runs a local MCP server on stdio with the same wallet and config.

claude mcp add council -- npx -y https://councilten.vercel.app/downloads/council-kit-0.1.0.tgz mcp

For Cursor, Codex or any client that takes a command, use npx -y https://councilten.vercel.app/downloads/council-kit-0.1.0.tgz mcp.

Tool	What it does
`council_status`	Balances and Venice credit. Read only.
`council_models`	Live catalog and alias targets. Read only.
`council_ask`	One model, inside a budget.
`council_convene`	The council, inside a budget.
`council_fund`	Venice top-up; requires `confirm: true`.
`council_pay`	x402 payment to an allowlisted host.
`council_ledger`	Spend history.
`token_info`, `token_holders`, `token_burns`	The mint, read from chain.
`wallet_send`, `token_burn`	Irreversible; marked destructive and refused without `confirm: true`.

Agents can read the rules in SKILL.md (also printed by council skill).

Configuration

~/.council/config.json, or council config <key> <value>.

Key	Default	Meaning
`rpc`	public mainnet	Solana RPC for payments and reads.
`mint`	not set	The Council mint.
`maxPaymentUsd`	1	Cap on any single payment.
`runBudgetUsd`	0.25	Default budget per run.
`allowHosts`	none	Hosts `pay` may pay without asking.
`seats`	venice, claude, gpt, grok, gemini	Default council.
`judge`	claude	The model that merges.
`maxTokens`	700	Output tokens per seat.

Environment: COUNCIL_HOME, COUNCIL_RPC, COUNCIL_MINT, COUNCIL_WALLET_KEY.

Security

The private key never leaves your machine. Every payment is a transaction signed locally and landed by the seller's facilitator.
Venice requests carry a fresh Sign-In-With-X signature each time: single use, five-minute lifetime, bound to the exact URL.
Not audited. Keep small balances in the agent wallet.
Council is independent and uses public APIs like any developer. It is not affiliated with Venice AI, BlockRun, Anthropic, OpenAI, xAI, Google or the Solana Foundation.