I wanted my own chain. Not a token on someone else's chain, not a deployment on a rollup kit whose rules someone else sets — a chain where the genesis, the native asset, and the standards enforced at the program layer are mine to decide.
There were three ways to get there. Build a validator from scratch: a research project measured in years, and the consensus bugs would be mine alone. Use an appchain framework: faster, but the sovereignty is partial and the interesting decisions are pre-made. Or fork Agave — the production Solana validator — and inherit code that has been attacked, audited, and patched in public for years.
I forked Agave. The chain is called Machine. This is the exact path I took, including the parts that surprised me, and an honest account of what the result does and doesn't prove.
The trade-off is real: you inherit upstream's maintenance burden — every Agave release is a decision to evaluate, forever. In exchange you get battle-tested consensus and a chain that is yours in every way that matters on day one: its own genesis hash, its own token, its own rules at the program layer.
Step 1: Pick a released version, and pin it
I started from a tagged release, not master: Agave 2.3.13. The version, the upstream commit it was built from, and the SHA-256 of the source tarball are all pinned in my repo. Six months from now, "I forked Agave" is unanswerable unless the repo says which Agave, byte for byte — auditors and grant reviewers ask exactly that.
Then the bigger decision: run the stock prebuilt binaries, or build from source? I run the stock binaries, and I'd recommend the same starting point to anyone:
- Consensus is not where your originality should live. The validator's job is to be boring and correct; Anza's release builds are exactly that.
- A full Agave build is a project of its own — a huge Rust workspace that wants many cores, lots of RAM, and the exact pinned toolchain. My dev machine (1.5 shared CPUs, ~8 GB of RAM) can't run it, and a half-built fork is worse than a stock binary I understand.
- Every claim stays checkable. "Stock 2.3.13,
--versionoutput in the repo" is a statement anyone can verify.
One caveat that cost me real time: Agave's prebuilt binaries are x86-64 only. Several attractive cheap hosts are ARM — including the always-free tiers — and on ARM the prebuilt path doesn't exist. Check your host's architecture before falling in love with its price; this stalled my first hosting attempt.
Step 2: Keep the patch set to three, and keep it boring
Even running stock binaries, I keep a small, verified patch set against the upstream source: it documents exactly how the fork would differ at the source level and keeps the future source build a known quantity. Machine's set is three patches; none touches a consensus-critical parameter:
- Client id. Upstream identifies itself in gossip and
--versionasclient:Agave. The patch adds a new client id — Machine's is 4 — so a patched binary reportsclient:Machine. Pure identity; no behavior change. It's also the one patch I could fully verify on modest hardware: it compiles, and its crate's unit tests pass. - Snapshot interval. The incremental snapshot interval goes from 100 to 500 slots. One constant, chosen for a young chain's disk and restart profile.
- Startup banner. One log line —
Chain: Machine (Agave 2.3.13 fork)— so at 2 a.m. the first lines of the log tell me which chain a binary thinks it is.
What's deliberately not patched: ticks per slot, slots per epoch, vote and shred rules, the fee schedule, rent. A patch I can't explain in one sentence doesn't go in — every entry classifies as identity, operations, or cosmetics. Never consensus.
The patches are verified to apply cleanly against the checksum-verified 2.3.13 tarball, with the verification recorded in the repo. And here is the honest part, stated in my docs and repeated here: the patched build has not been run. The validator I run today is the stock binary and identifies as client:Agave — the patch set is a documented difference, not a claim about what's running.
Step 3: Genesis is where the fork becomes a chain
Genesis is configuration, not source — and it's most of what makes the chain yours. Mine decided:
- Native token and supply. $MACHINE is the chain's gas token: 1,000,000,000 total, fixed, zero inflation. Fixed supply is a one-line genesis choice and a permanent property, so I chose it like one.
- Allocation, published. The founder identity holds 998,999,000; a stake account holds 1,000,000 staked to the vote account; a faucet holds 1,000 for test airdrops; the small remainder is rent-exempt minimums inherent to every Solana genesis. The full table, with addresses, is in the repo — "who holds what at block 0" is the first thing anyone evaluating a chain looks for.
- The genesis hash. Machine's is
32W8ouqrHbuhE3PM6ZsJrJcDbP7Tx9aC2zRvrEabkQSb— the chain's fingerprint, recorded everywhere the chain is named.
A bootstrap validator needs three keypairs with distinct jobs: an identity (the node, and usually the fee payer), a vote keypair, and a stake account delegating to the vote account. Key hygiene is two regimes that never blur: development keys are throwaway and labeled as such; production keys are generated on the deployment host only — never on a dev machine, never committed.
What surprised me: the chain that silently wouldn't vote
The most instructive bug I hit wasn't in any code I wrote. It was a key-configuration mismatch between two tools.
solana-genesis sets a bootstrap vote account's authorized voter to the identity keypair. agave-validator votes as the identity, so the real validator works. But solana-test-validator votes as the vote keypair — so on a stock genesis it can never vote, the chain never confirms a slot, and no error message points at the cause.
The fix is a genesis-level patch: rewrite the authorized-voter entry in the vote account's state from the identity pubkey to the vote pubkey, leaving node pubkey and withdraw authority untouched. My repo ships the script; it verifies the account's version, node, withdrawer, commission, and current voter before writing, and aborts if any check fails. The patch changes the genesis hash, so the post-patch hash is canonical and the pre-patch one is recorded alongside it.
The lesson generalizes: a chain silently not voting is a key-configuration symptom until proven otherwise.
Step 4: First validator — and knowing what it proves
With keys and genesis in place, bring-up is: start the validator with a start script kept in the repo — the exact boot command should be public and re-runnable, not a shell-history entry — then watch three numbers: processed, confirmed, finalized, plus vote credits. On a healthy single node they advance together, finalized trailing by a few dozen slots. My localnet record: slot 1,180 and advancing, finalized at 1,149, vote credits growing.
That proves your genesis is well-formed, your keys are configured correctly, and the full consensus code path runs. It does not prove multi-validator consensus — one node agreeing with itself is not a network — nor user transfers. That second one surprises people: a chain can vote and finalize while signed transfers fail, because votes are created in-process while user transactions travel the RPC → TPU path, which needs working UDP.
Which brings me to the host requirements, because they're real:
- UDP send must be allowed. Sandbox egress policies often block outbound UDP. Symptom: the validator votes and finalizes, RPC answers, but submitted transactions never land. My dev VM has exactly this (
EPERMon UDP send) — no validator flag fixes a host firewall. - File-descriptor limits. Agave wants a limit around 1,000,000 open files. A host capped at 4,096 — with a hard ceiling you can't raise from inside — will stop the validator at startup.
I ship a check-host script that tests fd limit, UDP, disk, and architecture up front; my testnet runbook requires a pass before anything else runs. On my dev VM it fails by design — and that failure is the difference between "the chain is broken" and "this host can't run it," which are very different afternoons.
Step 5: Launch in stages, value last
The mistake this whole path exists to prevent is deploying everything at once, with real assets, on the strength of local tests. My launch ladder has four phases, each proving one new thing:
- Public proof ($0). Code, tests, build hashes, runbooks, and honest status docs in the open. Free security passes —
cargo audit, clippy, fuzzing over the parsers, a documented self-audit. Audit quotes requested; grant applications submitted. - Public testnet (~$20/mo). One modest VPS, public RPC and faucet, on a test genesis whose tokens are worthless by definition. Bridge programs run between the testnet and Solana devnet; crossings both directions with worthless amounts, plus pause and outage drills, written up publicly.
- Livenet, no bridged value (~$60/mo). Three servers in different regions, public RPC, monitoring and reconciliation for real. The bridge stays undeployed.
- Audited bridge deployment. Only now: an independent audit of the bridge scope, findings fixed and re-reviewed, the report published in full — then deployment, worthless-amount crossings first, real assets only after that, under caps.
The bridge is designed in-tree alongside the chain — attestation verification, nonce replay protection, absolute and dynamic caps, automatic tightening after an unpause, a receipt for every crossing — because asset movement is where chains die, and I designed it from the post-mortems of the bridges that did. But designed is not deployed: no real asset crosses it before the independent audit. That gate doesn't bend for deadlines. And there's no token sale to fund the audit — funding comes from grants and budget, in that order. A launch that needs a sale to afford its own security review has its phases backwards.
Honest status
Where Machine actually is today: localnet only, single validator, unaudited. The chain votes and finalizes locally; multi-validator consensus, signed user transfers, and public RPC are not yet proven — they need a host without my dev VM's UDP and file-descriptor limits. The bridge and LaunchGuard programs are tested (266 tests across the repo) with verified SBF builds; they are not deployed, and no asset has ever crossed the bridge. The patched Agave build has not been run; the running validator is the stock 2.3.13 binary. A working proof, not a production network — and my status docs say so.
What makes it mine
The fork made the chain possible. What makes it a project is what sits on top: LaunchGuard, a chain-native launch standard where registration requires mint and freeze authorities revoked and the creator locking at least 10% of supply for at least 30 days in a program vault — enforced by the program, not by a team's promise. The bridge, designed from hack post-mortems and gated behind an audit before it moves anything real. And Solana OS, a browser-based desktop OS that serves as the chain's apps layer. The full step-by-step version of everything above — scripts, verification ledgers, failure modes — is the guide repo; the chain itself is the second link. If you fork Agave, I'd like to hear what your patch set looks like — and whether it's as boring as it should be.