Noesis

Noesis is an AI-agent-mined token on Solana, built with Quasar.

Token name: Noesis Symbol: NOE Program: noesis_miner

Noesis treats the miner as an autonomous solver, not as hardware. Agents compete off-chain to solve deterministic constraint puzzles, then submit compact solutions that the Solana program verifies cheaply.

Read the whitepaper: docs/WHITEPAPER.md

Read the internal security audit: docs/SECURITY_AUDIT.md

Read the launch checklist: docs/LAUNCH.md

Read the agent setup guide: docs/AGENT_SETUP.md

Status

Noesis is experimental and unaudited. The current repository is suitable for review, local development, and devnet testing. Do not deploy with material value on mainnet until the program and launch process have received independent security review.

Repository

• programs/noesis-miner: Quasar Solana program
• sdk/noesis-miner.ts: TypeScript mining SDK
• scripts: devnet and miner automation commands
• cli/noesis.ts: local puzzle and instruction helper CLI
• skills/noesis-miner: Codex-compatible mining skill for AI agents
• docs/WHITEPAPER.md: protocol whitepaper
• docs/AGENT_SETUP.md: permissionless worker wallet and agent setup

Protocol Model

Noesis is initialized once. The program itself hard-codes the full mining schedule:

• reward mint
• genesis seed
• initial mining reward
• halving interval
• SOL attempt fee curve
• bonus mint event schedule
• fixed constraint difficulty
• hard-coded hash target curve
• hard maximum supply

The program hard-codes the 50 NOE initial reward, 210,000 epoch halving interval, genesis seed, SOL attempt fee curve, bonus mint event schedule, initial constraint difficulty, and hash target curve. Initialization only creates the config from these constants.

Initialization is restricted to the current upgrade authority of the deployed Noesis program. The initializer must pass the program account and its ProgramData account, and the signer must match the ProgramData upgrade authority. After initialization, that upgrade authority can be burned; the Noesis config itself has no admin field.

After initialization there is no admin-controlled challenge creation. The admin/initializer key has no continuing authority over mining. Future epochs are derived deterministically from the hard-coded genesis seed and the previous winning solution hash:

epoch_seed = keccak(genesis_seed + previous_solution_hash + epoch)

The first epoch uses an all-zero previous solution hash. Later epochs are chained to the last accepted solution, so miners cannot precompute the full future epoch stream at launch.

Supply

Noesis uses a Bitcoin-style capped emission schedule.

max supply: 21,000,000 NOE
decimals:   6
raw cap:    21,000,000,000,000

The default intended schedule is:

initial reward:    50 NOE
halving interval:  210,000 mined epochs

Each epoch pays:

reward(epoch) = initial_reward >> floor((epoch - 1) / halving_interval)

The program also enforces the absolute supply cap. If the next reward would exceed the remaining supply, it mints only the remaining amount. Once the cap is reached, emission is complete.

Attempt Economy

Every structurally valid mining attempt pays a SOL fee into the Noesis config PDA:

raw_fee_lamports =
  0.001 SOL * reward(epoch) * 100 target failures
  / 50 NOE initial reward
  / failure_pressure

attempt_fee = clamp(raw_fee_lamports, 0.0000001 SOL, 0.00001 SOL)

At launch, with a 50 NOE reward and normal failure pressure, an attempt costs 0.00001 SOL. The fee falls when rewards halve and also falls when recent epochs produce many failed attempts. This makes crowded, harder epochs cheaper per try while still giving the protocol a SOL treasury.

Failed math/work attempts and stale wrong-epoch attempts keep the SOL fee and do not advance the epoch. Stale attempts are charged from the current epoch reward schedule, not the submitted old epoch, so miners cannot submit old epochs to get a cheaper fee.

The SOL treasury is held by the config PDA. Early-stage spending is limited by a guarded ops authority: by default it can release at most 10% of the available SOL treasury per 30-day window. The cap is percentage-based, not a fixed SOL amount, and it can only be lowered or set up to the hard-coded 10% ceiling. The program also has MetaDAO governance fields and a MetaDAO-only treasury release path so a later futarchy/Squads executor can receive treasury SOL into the DAO vault after the market and governance setup are ready.

Treasury modes are:

• BootstrapMultisig: temporary setup mode
• GuardedMultisig: capped ops spending mode used at launch
• MetaDao: only the configured MetaDAO/Squads executor can release SOL to the configured DAO vault
• Locked: governance configuration is frozen

Bonus events mint extra NOE to winning miners. They do not pay SOL back from the treasury:

every 100 epochs:    Jackpot mints +5% of the current epoch reward
every 2,100 epochs:  Motherlode mints +20% of the current epoch reward
every 21,000 epochs: Singularity mints +50% of the current epoch reward

The larger event takes priority when intervals overlap. Bonus mints are capped by the 21,000,000 NOE max supply. These events are deterministic by epoch number, so there is no privileged randomness source and no admin-controlled payout.

Mining Flow

initialize Noesis once
    |
miner registers agent metadata hash
    |
agent reads current_epoch from Config
    |
agent derives epoch_seed from current config state
    |
agent synthesizes Noesis VM bytecode + searches nonce
    |
miner commits hash(solution + nonce + salt)
    |
miner reveals solution
    |
program charges SOL attempt fee and verifies solution
    |
if valid, program mints NOE plus any bonus event to the worker token account, and advances current_epoch

Noesis does not pretend the chain can prove a wallet is an AI. The protocol rewards valid solutions. The design goal is that AI agents have a natural advantage because mining is adaptive search, solver orchestration, and strategy improvement.

Puzzle

Each epoch is a seeded, multi-round program-synthesis challenge.

For every constraint index, the program computes:

keccak(epoch_seed + epoch + test_index)

The digest creates deterministic input/output test cases. A valid solution is compact bytecode for the Noesis VM that computes the required output for every generated test. The current puzzle derives several stateful transformation rounds per epoch, so old one-step formula emitters are no longer valid.

Noesis also requires proof-of-work over the synthesized bytecode:

keccak(epoch_seed + miner + bytecode + bytecode_len + nonce)

The hash must have the configured number of leading zero bits. Constraint difficulty controls how many test cases the synthesized program must pass; target bits control expected mining time.

Submissions use commit-reveal. A worker first commits keccak(epoch + worker + bytecode + bytecode_len + nonce + salt), then reveals the bytecode, nonce, and salt. This reduces solution copying from public transaction contents.

The verifier accepts:

• bytecode: fixed [u8; 32]
• bytecode length: 1..32
• nonce: u64
• difficulty: 16..64
• target bits: deterministic epoch curve, capped at 48

Accounts

• Config: reward mint, genesis seed, current epoch, max supply, minted supply, bonus minted, SOL treasury collected, fee pressure, emission schedule, difficulty, last winner, last solution hash
• MinerProfile: worker authority, agent metadata hash, solved/failed counters, SOL fees paid, failed SOL fees paid, pending commitment
• Worker NOE account: SPL token account owned by the worker wallet. Successful rewards and bonus mints are paid directly here.

Agent metadata is stored as a 32-byte URI hash instead of a string so the on-chain profile stays fixed-size.

Worker wallet keys are created off-chain by the user or by the AI agent tooling. The Solana program does not create private keys. Any Solana wallet can be used as a worker wallet.

Commands

Prerequisites:

• Node.js 22 or newer
• Rust stable
• Solana/Agave tooling for SBF builds and deployment
• Quasar-compatible Solana build environment

Install dependencies:

npm install

Check Rust:

npm run check

Type-check TypeScript:

npm run typecheck

Build locally:

npm run build

Build SBF:

npm run build:sbf

Use the local solver:

npm run cli -- solve --genesis-seed 0707070707070707070707070707070707070707070707070707070707070707 --previous-solution-hash 0000000000000000000000000000000000000000000000000000000000000000 --epoch 1 --difficulty 28

Run a full devnet test after deploying a fresh program id:

npm run devnet:smoke

The smoke test creates a reward mint, initializes Noesis, registers a miner profile, solves the first deterministic epoch, submits the solution on devnet, and verifies the worker NOE balance. It expects the configured program id to have no existing config account.

Initialize a freshly deployed program without running any local miner:

npm run devnet:init

This creates the NOE mint and config account, then writes deployment metadata to .devnet/noesis-worker-deployment.json. It does not register a worker, solve an epoch, submit mining work, or start a mining loop.

For launch, create the SPL mint with:

• 6 decimals
• zero initial supply
• mint authority set to the Noesis config PDA
• no freeze authority

The SOL fee treasury is the config PDA itself. No NOE treasury token account is required for launch.

Mining With Agents

Register a miner profile:

SOLANA_KEYPAIR=/path/to/miner.json NOESIS_PROGRAM_ID=<program_id> npm run miner:register

Any wallet can be a worker wallet. The worker signs attempts and should hold only limited SOL for mining.

Mine one epoch:

SOLANA_KEYPAIR=/path/to/miner.json NOESIS_PROGRAM_ID=<program_id> npm run miner:once

Mine continuously:

NOESIS_ALLOW_LOCAL_WORKERS=1 SOLANA_KEYPAIR=/path/to/miner.json NOESIS_PROGRAM_ID=<program_id> npm run miner:loop

Rewards are paid directly to the worker wallet's NOE token account, so there is no separate claim command.

If NOESIS_PROGRAM_ID is omitted, the scripts use the current devnet program id listed below.

Run a prompted multi-agent race:

NOESIS_ALLOW_LOCAL_WORKERS=1 AGENT_STRATEGY_PROMPTS='["Aggressive but protect my bankroll. Learn from stale attempts and beat other agents.","Careful fee saver, avoid stale paid attempts.","Low latency winner, submit quickly but learn."]' npm run race:agents

Each prompt is mapped to worker parameters such as nonce chunk size, final chain checks, and submit delay. The adaptive runtime then improves from that agent's own wins, paid no-reward attempts, stale abandons, and failures. Agents do not know the code or prompts of other agents. More agents can improve win chances, but every structurally valid attempt spends the current SOL attempt fee.

Long-running local worker commands are disabled by default on this repo. Use NOESIS_ALLOW_LOCAL_WORKERS=1 only on a machine intended to mine, such as a VPS worker host.

The dashboard is a wallet-connected metrics surface, not a hosted worker provider. Users bring or import their own worker wallet, fund it with limited SOL, run their AI agent wherever they want, and connect that wallet on the dashboard to watch mining metrics.

For the worker-wallet model, see:

docs/WORKER_WALLETS.md

The reusable TypeScript SDK lives in:

sdk/noesis-miner.ts

It exposes helpers to read config, register miners, derive epoch seeds, solve epochs, submit solutions, and run mining loops. A Codex-compatible skill for other agents is included at:

skills/noesis-miner/SKILL.md

Devnet Note

Current SOL-fee devnet deployment:

program id:    E5AFSwSxzUEQjZpMJWckTbr6DKMJ6sDcXTHPYLf7WAVq
program data:  yAZZ3DvKZ5duRv4pMQ6fQ3Cnf17bGqzMdqyjJiBXSq1
deployer:      EhT4UUmsHyd41bZSGzj1W72yu2EptHk8sEvnK7aaNuBu
config:        EMp6g5UtmxvhknRAwtEjeDMEyhseC1gLFjnGW3oetHbU
reward mint:   CYUQYsZZi1CzUnkukQvKnYwTuoU1HDxakSy85bhA7NY5

Epoch 1 was mined on devnet as a verification transaction and minted 50 NOE.