Identity is fragmented
Accounts, devices, organizations, and agents live behind unrelated identity systems with no shared authorization language.
Discover / Why Actum
The foundations were built for another world.
The next internet will be populated by people, organizations, devices, services, and autonomous agents. They need a common way to express identity, authority, privacy, and verifiable computation.
Why now
Authority is implicit
Applications routinely infer permission from possession of a key, a session, or an opaque platform role.
AI acts without receipts
Agents can call tools and move value, yet the exact policy, model, input, and budget behind an action are hard to verify.
Cryptography is aging
Critical internet infrastructure was not designed for a credible post-quantum migration across every authorization boundary.
The next trust layer must verify not only who signed, but what they were allowed to do—and why the result should be accepted.
The design thesis
Some foundations cannot be repaired with another layer.
Actum tests whether identity, capability-safe authorization, proof-carrying computation, private state, and post-quantum security become simpler when they share one semantic core.
Authority is explicit
Every action must be authorized by a scoped, machine-verifiable policy.
Computation carries evidence
Important results arrive with a proof or an explicitly labeled assurance receipt.
Specialization without trust
Infrastructure providers can specialize without gaining control over validity.
Why a new L1
Another chain must justify every new trust assumption.
This is not a claim that existing chains are obsolete. Ethereum leads in composability, Aztec in programmable private state, Solana in optimized execution, Starknet in provable computation, and Cosmos and Polkadot in modular sovereignty. Actum’s narrower bet is that authority, privacy, evidence, and post-quantum validity need one coherent boundary.
The properties must compose at one validity boundary.
Actum is testing whether post-quantum authentication and finality, explicit principals and attenuating authority, private objects and policies, resource-safe execution, and proof-carrying AI jobs can be checked as one atomic transition.
A clean slate is a liability until evidence says otherwise.
Actum must bootstrap validators and users, fund independent audits, operate a post-quantum prover and wallet stack, build bridges without importing hidden trust, and demonstrate safety, liveness, recovery, and useful performance.
What it already does well
The strongest composability, liquidity, tooling, and settlement ecosystem, with account abstraction continuing to improve wallet safety and UX.
Why Actum is not identical
Actum is testing a protocol whose authorization, consensus signatures, private objects, and proof admission share one post-quantum, typed semantic boundary. Reproducing that on Ethereum would distribute the design across contracts, wallets, rollups, bridges, and operators with different upgrade and trust assumptions.
What it already does well
A sophisticated privacy-first Ethereum L2 with public and private execution, encrypted notes, nullifiers, account contracts, and Noir developer tooling.
Why Actum is not identical
Aztec is the closest reference for programmable private state. Its center is a privacy rollup settling to Ethereum; Actum's target also includes sovereign post-quantum consensus, native principals and attenuating capabilities, proof-carrying agent authority, and protocol-wide evidence composition.
What it already does well
A broad private-by-default stack spanning local software, messaging, storage, mixnet networking, private transfers, and blockchain infrastructure for network states.
Why Actum is not identical
Logos is philosophically close and worth learning from. Actum is narrower around a globally verifiable authority and computation layer: typed objects, explicit policy, accountable agents, post-quantum transition authorization, and published formal launch gates.
What it already does well
A mature, performance-oriented runtime where stateless sBPF programs operate on explicitly supplied accounts and multiple instructions compose atomically.
Why Actum is not identical
Actum is not trying to beat Solana at its optimized execution model. It makes identity, delegated authority, private state, evidence policy, and post-quantum consensus part of validity itself.
What it already does well
A production-oriented validity-rollup architecture with Cairo, recursive STARK aggregation, Ethereum settlement, and native smart-contract accounts.
Why Actum is not identical
Starknet demonstrates provable execution and native account abstraction. Actum's different bet is an end-to-end post-quantum safety path plus first-class credentials, capabilities, objects, private authorization, and accountable compute jobs.
What it already does well
The pragmatic route to a customizable sovereign chain: composable application modules, CometBFT consensus, a clean application boundary, and native IBC interoperability.
Why Actum is not identical
Cosmos is the strongest argument against starting from zero. Actum chose custom kernels because canonical post-quantum envelopes, weighted finality evidence, affine authority, ObjectVM resources, and proof-bound admission cross the normal application/consensus boundary.
What it already does well
Parachains offer specialized state machines with relay-chain shared security, interoperability, and scaling instead of bootstrapping every security function alone.
Why Actum is not identical
A parachain would reduce bootstrap risk, but Actum would inherit the relay security and integration boundary rather than validate its own post-quantum consensus and proof-composition thesis.
The decision rule
If Actum cannot demonstrate that these properties compose more safely and legibly at protocol level, deploying on—or integrating with—an established network is the better engineering decision. This project exists to test that thesis in public.