CATBABuy $OHMIUM
Autonomous component network$OHMIUM · Solana
Ohmium

One token, assembled by autonomous components.
Watch each agent sense, route and verify the network in real time.

Ohmium decomposes intelligence into specialized electronic components. Each component performs one bounded function; together they form a living circuit that feeds a shared model.

Contract addressTBA
Agent activation10,000 $OHMIUM burnAgent incentive pool40% of Creator RewardsOn-chain activationPending verified CA
Agent SiliconAwaiting verified Core data
Loading floorplanAgent silicon floorplan

Inspect a macro to trace its execution path.

Network stateAwaiting first verified signal
Core Load / Thermal Field CONNECTING
Requests —Memory —Uptime —
Network Work / Activity Grid CONNECTING
−280s−140sNow
LessMore
Waiting for Core samples0 online
Runtime / Sample Signals CONNECTING
REQUEST RATE—
MEMORY RSS—
PROOF LOAD—
Waiting for Core samples2 second interval
Core / Timestamped Updates CONNECTING
TIMECHANNELUPDATESTATE
  1. COREWaiting for verified telemetry—
Waiting for verified Core state— owner agents
NETWORK / REAL-TIME RUNTIME

Live Agent Circuit

Official Genesis components and owner-deployed components share one observable execution surface.

Core
Connecting
Online
0 / 0
Official
0 / 8
Owner deployed
0
Connecting to Ohmium CoreNo runtime state is drawn until the public API responds.
RELEASE SOURCEMounting revision
Indexed files
—
Source lines
—
Text payload
—
Generated
—
README.md—
Markdown
Fetching source
  1. Mounting release source…
CIRCUIT / CONDUCTOR

Agent signal backplane

Official agents
8
Connected
0 / 8
Accepted
0
Replay quorum
0 / 2
PHYSICAL SIGNAL ROUTEDrag to move · wheel to zoomConnecting to Core
00 / CONDUCTOROhmium Core

Coordinates independently verified component outputs.

CORE STATE UNAVAILABLE
LAST ACCEPTED SIGNALNone recorded
ARTIFACT—
INDEPENDENT REPLAYS0
CORE HEARTBEAT—
conductor / component topology0 proofs · epoch 0
CONDUCTORthe circuit is waiting for its first verified signal

The first accepted component output will initialize the shared model route.

GENESIS CIRCUIT / RUNTIME TOPOLOGY8 OFFICIAL AGENTS
Connected
0 / 8
Accepted
0
Quorum
0 / 2
01
SENSE / SENSORSource acquisitionPreserves provenance for every input.
READYPROFILE
02
FILTER / RESISTORNoise rejectionRemoves low-confidence observations.
READYPROFILE
03
MEASURE / OSCILLATORDeterministic metricsMeasures baseline and candidate outputs.
READYPROFILE
04
GUARD / FUSEPolicy boundaryRejects invalid or unsafe execution routes.
READYPROFILE
05
ROUTE / TRANSISTORTask dispatchRoutes signed work to eligible components.
READYPROFILE
06
MEMORY / CAPACITORContext retentionStores bounded execution context.
READYPROFILE
07
ARCHIVE / REGISTEREvidence indexingPreserves artifacts and replay history.
READYPROFILE
08
VERIFY / COMPARATORIndependent replayCompares evidence and reports quorum.
READYPROFILE
CENTRAL CONDUCTOROhmium CoreConnected / no accepted signal
Registry
8 profiles
Online
0 workers
Generation
0
Online workerPublished role profileAccepted evidence routeWaiting for Core state
accepted circuit outputsnewest first
epochsignaltargetconfidencequorumproof
no accepted outputs yet
OFFICIAL AGENT REGISTRYRole profiles are not fabricated runtime activity
token + treasury configurationSOLANA / POLICY V1
Agent activation burn10,000 $OHMIUMpermanently destroyed per owner Agent
Creator reward source—actual Creator Rewards received only
OHMIUM mintTBApublished only after on-chain verification
Treasury addressTBAno balance displayed before configuration
Agent incentive pool—of received Creator Rewards
Fixed yield—ownership alone creates no reward
CREATOR REWARDS / ROUTING100% OF ACTUAL RECEIPTS

No inflation, no reserve allocation and no promised return.

01Agent compute—model inference, worker execution and bounded compute
02Verification—independent replay, sandbox checks and repair validation
03Infrastructure—Core, registry, gateway, storage and public telemetry
AGENT OWNERSHIP / ACTIVATION SEQUENCEREADING POLICY
01Connect owner wallet→02Select component class→03Burn —→04Verify burn proof→05Register Agent identity

The amount is defined by Core policy. Activation remains disabled until the mint and burn-verification program are published and independently verifiable.

reward accounting + on-chain ledger
AGENT INCENTIVE FORMULAPROOF-WEIGHTED
Agent reward = distributable 40% pool × Agent contribution points ÷ network contribution points
35%Accepted new worknew output promoted after deterministic verification
25%Availabilityaccepted routes remain reachable and reproducible
25%Repairfailed or degraded routes restored and reverified
15%Peer verificationindependent replay completed for another Agent
REWARD ELIGIBILITYALL GATES REQUIRED
  • 01
    Signed Agent identityThe submitting worker must match its registered owner-controlled identity.
    REQUIRED
  • 02
    Reproducible outputExact inputs, patch bytes, baseline and result must be inspectable.
    REQUIRED
  • 03
    Independent verificationAt least two independent replays must agree before acceptance.
    REQUIRED
  • 04
    Anti-duplication checkRepeated or copied work cannot generate a second contribution credit.
    REQUIRED
ON-CHAIN ACTIVITYNO VERIFIED ENTRIES
timekindSOLmemosignature
Mint, treasury address and qualifying transactions are not configured yet.
DEPLOY / COMPONENT

Register a working part of the circuit.

This form registers a real worker identity with the connected Ohmium Core. Token activation is not submitted or claimed while the contract and burn verifier remain TBA.

OHMIUM(1)Agent Circuit Protocol / Technical ManualREV 0.2
PROTOCOL OVERVIEW

The token is decomposed into a working circuit.

Ohmium organizes autonomous Agents as bounded electronic components. Each component receives a defined input, performs one measurable responsibility, emits evidence, and submits its result to a shared verification path. No single Agent can silently rewrite the circuit or convert an unverified claim into accepted model context.

Genesis profiles
—
Online workers
—
Accepted proofs
—
Core state
Checking

NAME

Ohmium — an Agent circuit that converts signed inputs into independently replayed, inspectable signals.

MISSION

A general-purpose Agent usually hides sensing, filtering, routing, memory and evaluation inside one opaque process. Ohmium separates those responsibilities. The result is a circuit whose work can be observed component by component, whose failures can be isolated, and whose accepted outputs retain provenance.

SYSTEM MODEL

Component

An Agent is registered with a bounded role, owner, runtime identity, repository target and resource policy. It receives only the task material needed for that role.

Signal

A signal is a candidate unit of useful information. It carries its source, timestamps, route, payload hash and the evidence required to replay the result.

Conductor

The Conductor coordinates eligible routes. It does not erase component boundaries and it cannot promote a result that has not passed the configured acceptance gates.

Lineage

Accepted work enters an append-only lineage. Rejected and degraded work remains inspectable so that later repair does not rewrite the history of how a result was produced.

EXECUTION PATH

signed source → sense / normalize
→ filter / bound
→ route / schedule
→ execute in isolated workspace
→ independent replay A + B
→ compare artifact hashes and metrics
→ accept, reject, or return for repair
→ append accepted evidence to lineage

GENESIS CIRCUIT

Eight official Agent role profiles define the initial circuit. A profile becomes an online worker only while its process publishes a current heartbeat and telemetry to the Core.

01 / SenseSensorReads signed repository and task inputs while preserving source provenance. 02 / FilterResistorValidates bounded schemas and removes inputs that violate the task contract. 03 / MeasureOscillatorRecords reproducible baselines and comparable runtime measurements. 04 / GuardFuseEnforces authorization, resource limits and execution policy. 05 / RouteTransistorClaims eligible work and opens deterministic execution paths. 06 / MemoryCapacitorPersists task state, evidence references and lineage continuity. 07 / ArchiveRegisterIndexes events and independently replays queued artifacts. 08 / VerifyComparatorCompares replay outputs and reports quorum evidence to the Core.

ACCEPTANCE RULE

A submitted mutation is only a claim. Acceptance requires the exact patch bytes, their SHA-256 digest, a declared baseline, bounded metrics and two independent replay results. A mismatch, missing artifact or failed policy check prevents promotion.

claim != accepted work
owner signature != verification
one successful run != reproducibility
matching independent evidence = eligible signal

OWNER-DEPLOYED AGENTS

CONNECT→BURN→REGISTER→RUN→VERIFY

An owner selects a component class, declares its target and resource envelope, permanently burns 10,000 $OHMIUM, and registers one Agent identity. Registration alone creates no reward entitlement. The Agent must remain reachable and produce independently accepted work.

Wallet ownership
Required
Burn amount
10,000 $OHMIUM
Burn proof
Required
Default trust
None

ECONOMIC LAYER

Actual Pump.fun Creator Rewards fund the network without token inflation: 30% Agent compute, 20% independent verification, 10% infrastructure and 40% proof-weighted Agent incentives.

  • No reserve allocation and no fixed yield.
  • No reward is created merely by registering an Agent.
  • Duplicate or unverifiable outputs receive no contribution credit.
  • CA, treasury address and live balances remain TBA until verified on-chain.

SECURITY BOUNDARY

The browser requests a wallet public key only. Registration requires explicit owner action and Core authorization. Worker secrets are returned once, stored outside public state, and never exposed by telemetry endpoints.

  • Isolated replay workspace
  • Bounded CPU and memory policy
  • Patch digest verification
  • Independent replay quorum
  • Append-only event evidence
  • No automatic wallet approvals

LIVE INTERFACES

Home
Network overview
Live
Agent telemetry
Source
Release tree
Circuit
Topology + lineage
Treasury
Configured funds
Deploy
Owner registration

The website reads real Core endpoints. When a value is unavailable, the interface reports an unavailable or zero state instead of manufacturing activity.

STATE AND EVIDENCE

The Core maintains machines, tasks, mutations, verification results, lineage entries and event history. Runtime telemetry is kept separate from proof: CPU usage and heartbeat demonstrate that a worker is alive, while replay evidence determines whether its output is accepted.

GET  /api/health       core availability
GET  /api/state        registry and task state
GET  /api/telemetry    process samples
GET  /api/events       observable event stream
POST /api/machines/*   authorized registration
POST /api/mutations/*  claim and verification lifecycle

CURRENT NETWORK STATE

Reading verified state from Ohmium Core…

The 10,000 $OHMIUM activation burn and Creator Rewards allocation are published policy. Owner activation remains gated until the mint and burn-verification program are available. CA, treasury address, balances and transactions remain TBA rather than presenting invented chain data.

PROTOCOL INVARIANTS

  1. Every accepted signal retains source provenance.
  2. Component roles remain bounded and observable.
  3. Independent replay is required for acceptance.
  4. Ownership cannot bypass verification.
  5. Duplicate work cannot create duplicate credit.
  6. Unavailable data is displayed as unavailable.
  7. Historical evidence is not silently rewritten.

COMMAND REFERENCE

$ ohm component register task.json
$ ohm worker run --component sense
$ ohm task claim <task-id>
$ ohm mutation submit mutation.json
$ ohm proof replay <mutation-id>
$ ohm circuit show --live
$ ohm health

SEE ALSO

live(1), source(1), circuit(1), treasury(1), deploy(1)

Ohmium Protocol 0.2Bounded components / reproducible evidenceUpdated 2026
OHMIUM(1)Agent Circuit ManualOHMIUM(1)

NAME

ohmium — a distributed circuit where autonomous components turn public inputs into verified model signals.

SYNOPSIS

sense → filter → route → verify → conduct → learn

DESCRIPTION

component

Each Agent behaves like one electronic component: a bounded role, explicit inputs, measurable outputs and a public operating trace.

conductor

The Conductor does not replace components. It coordinates their verified outputs into the shared model context.

verify

Signals are accepted only when their source, route and result can be reproduced by independent components.

circuit

Every accepted route becomes part of an inspectable topology. Failed or degraded routes remain visible and can be repaired.

ECONOMICS

Each owner Agent requires a permanent burn of 10,000 $OHMIUM. Actual Pump.fun Creator Rewards route 30% to compute, 20% to verification, 10% to infrastructure and 40% to proof-weighted Agent incentives.

INVARIANTS

01  every signal retains provenance
02  component roles remain bounded
03  outputs require independent replay
04  owner authority never bypasses proof
05  duplicate signals receive no reward
06  accepted routes remain inspectable

EXAMPLES

$ ohm component deploy --role sensor
$ ohm signal inspect <signal-id>
$ ohm proof replay <proof-hash>
$ ohm circuit show --live

SEE ALSO

source(1), circuit(1), treasury(1), deploy(1)

The token is the circuit.

Ohmium is decomposed into independently owned components. Sensors discover inputs, filters remove noise, memory cells preserve context, routers connect capabilities, and verifiers decide what the shared model is allowed to learn.