Most of crypto starts from the application and works down, hoping the foundation holds. We started from the foundation. The premise of GOAT Network is that the bottom of any financial stack - the layer where a balance becomes a fact that no operator, council, or issuer can reverse - should be the most neutral and most attack-costly ledger that exists.
Today that ledger is Bitcoin.
Everything in the GOAT Stack exists to carry that one guarantee upward: from Bitcoin’s settlement, through a trust-minimized bridge, into a fast zkEVM execution environment, and out to the payment, identity, and application layer where humans, institutions, and autonomous agents actually transact.
This article walks the stack the way it’s built - bottom to top - and then, at the top, flips perspective to follow a single agent payment down through the layer it touches.
We’ll answer the questions that matter: how does value move to and from Bitcoin without a custodian, what runs on top, and what can an agent actually pay for today. We’ll also be straight about which layers are battle-tested and which are still hardening.
TLDR
The four layers of the GOAT Stack, bottom to top:
- Bitcoin - the settlement layer. Not “Ethereum security”, not “committee security”. Final settlement anchored to the most proven proof-of-work ledger in existence.
- The settlement bridge (BitVM2/BitVM3-class) - value moves to and from Bitcoin under a 1-of-n honesty assumption: a single honest participant is enough to stop fraud. This is the layer that turns “secured by Bitcoin” from a slogan into a mechanism. (Maturing: live on testnet, advancing toward mainnet - see the honesty note below.)
- The GOAT execution layer - a Type-1 zkEVM with real-time ZK proving and a decentralized sequencer network. Full EVM programmability, sub-3-second proving, settling proofs down to Bitcoin.
- The agent & application layer - where value becomes usable: agent wallets, AgentKit for seamless integration (including identity via ERC-8004), multi-chain agent payments (x402 and MPP), and the application and merchant surface agents transact with - all resting on a strict compliance and licensing foundation.
The GOAT Stack: value that settles on Bitcoin, carried upward through four layers - finality at the base, usability at the top.
Layer 1: Bitcoin, the Settlement Layer
Every other layer in this stack inherits its finality from this one, so it’s worth being precise about what “settles on Bitcoin” means and why we chose it.
A payment is a message - an instruction, an authorization, a balance update inside some system. Settlement is a fact: the point past which a transfer cannot be reversed, censored, or renegotiated by anyone, including the operator of the system it happened on. Most of the digital economy runs on deferred settlement - balances that are final in practice only as long as an institution stays solvent, cooperative, and politically unpressured. For human commerce backed by courts and contracts, that’s usually fine. For value that needs to be final on its own terms - institutional settlement, cross-jurisdictional transfers, and increasingly machine-to-machine payments with no legal recourse between counterparties - the settlement layer itself has to be neutral.
Bitcoin is the only ledger that clears that bar today: seventeen years without a controlling party, secured by physical energy spent outside the system, with a security record no other chain can claim. Its network crossed a zettahash per second of hashrate in early 2026; even the year’s sharpest hashrate shock produced zero loss of finality.
That is the property GOAT Network is built to extend upward - not to replace Bitcoin’s base layer, but to make its settlement guarantee reachable from a programmable environment.
What Bitcoin can’t do is execute. Its base layer was never meant to host a high-throughput economy, and it shouldn’t try to. Settlement on Bitcoin should not mean computing on Bitcoin. Bridging that gap - neutrality at the bottom, programmability above it - is the job of Layer 2.
Layer 2: The Settlement Bridge
The hardest problem in Bitcoin Layer 2 design is moving value to and from Bitcoin without reintroducing the very trust you came to Bitcoin to avoid.
Most “Bitcoin” bridges are federated multisigs wearing a Bitcoin costume: a quorum of signers you have to trust not to collude. In collaboration with its designer, @Robin_Linus, GOAT Network’s settlement bridge is built on the BitVM2 line of research (and its evolutions, the BitVM3-class garbled-circuit constructions), whose defining property is a far weaker trust assumption: 1-of-n honesty. As long as a single honest participant is watching, fraud can be detected and stopped on Bitcoin itself. You don’t trust a majority; you rely on there being at least one honest party - and you can be that party.
The mechanism, in plain terms: when an operator tries to move bridged value, their claim enters a pre-signed challenge game enforced by Bitcoin. If the claim is honest and unchallenged, settlement proceeds. If it’s fraudulent, any honest watcher can issue a challenge that ends - after an optimistic dispute window - in a check that Bitcoin Script executes natively, and the dishonest operator forfeits their collateral. The deep engineering work here is making that dispute cheap enough to actually run within Bitcoin’s constraints, which is exactly what the BitVM3-class constructions achieve: collapsing on-chain dispute resolution down to a single hash check, with setup that runs on commodity hardware.
An honesty note: this is the newest and most actively evolving part of the stack. The 1-of-n bridge model is the strongest trust assumption Bitcoin interoperability has ever had - but it is years old, not decades, and anyone who tells you Bitcoin L2 bridges are as proven as Bitcoin itself is selling something.
GOAT Network’s bridge is live and observable on testnet and advancing toward mainnet with deposit limits and staged hardening rather than a flip-the-switch launch. The full trust model - every party, every assumption, and the cases where it falls back - is published separately, not buried here.
We bet the entire project on maturing this construction in the open rather than on a multisig federation, and we’d rather show you the process than ask you to take the word on faith.
Layer 3: The GOAT Execution Layer
Above the bridge sits where things actually run: a Type-1 zkEVM. “Type-1” is the strict end of the spectrum - it means full equivalence with Ethereum, so existing Solidity contracts, tooling, and developer habits work without modification. Anything you can build on Ethereum, you can build on GOAT Network, with Bitcoin underneath instead of Ethereum.
Two pieces make this layer work.
The first is real-time proving: every batch of transactions is compiled into a zero-knowledge validity proof attesting that the state transition was correct. GOAT Network’s proving pipeline - built on the Ziren zkVM, a MIPS-based prover developed by the our ZK research branch (@ProjectZKM) and independently audited - generates these proofs fast enough to keep pace with block production, with sub-three-second proving demonstrated in testing. Validity proofs mean the network’s correctness is verified by mathematics rather than asserted by an operator, and those proofs settle down to Bitcoin through the bridge.
(Note: we're one of the only Bitcoin L2 teams - possibly the only team - running our own zkVM in production, independently audited. Outsourcing this crucial part means inheriting someone else's roadmap for maintainability, upgrades, and how fast a critical bug gets fixed - which is unacceptable.)
The second is a decentralized sequencer network. Sequencers order transactions, execute them, and publish state.
Centralized sequencers are the quiet single point of failure in most L2s. GOAT Network runs a decentralized set whose composition is itself committed to Bitcoin, so the canonical state an operator must prove against is anchored to the base layer rather than to the operator’s good behavior. This is also what lets the system resist the operator double-spend problem that a naive Bitcoin rollup would inherit.
The result is a familiar, fully programmable EVM environment that feels like any modern L2 to a developer - and whose finality, uniquely, traces to Bitcoin.
Layer 4: The Agent & Application Layer
A settlement guarantee nobody can use is just a research paper. The top of the GOAT Stack is where Bitcoin-anchored execution becomes something people, institutions, and especially autonomous agents transact on - built in, not bolted on.
To see how it fits together, flip the perspective. The three layers below build upward from settlement. This one is best read downward, the way value actually moves: start with an agent at the top and follow a single payment as it travels through a wallet, a toolkit, a payment rail, and finally out to whatever it’s buying. That top-down path - an agent’s-eye view of the stack - is the GOAT agentic payment map.
The GOAT agentic payment map: follow a payment down from an agent, through its wallet, AgentKit (ERC-8004 identity), multi-chain payment, and out to the merchant surface - all on a compliance foundation, all settling on Bitcoin.
Agents - the actors. An autonomous agent - analyzing, negotiating, transacting at machine speed on behalf of a person or a business - is the user this layer is designed around. Everything below exists so that an agent can hold value, prove who it is, pay, and get paid, without a human in the loop for each step.
Agent wallets. Before an agent can transact it needs somewhere to hold keys and value. Rather than force one proprietary wallet, GOAT Network integrates established agent-wallet infrastructure so builders can use the key-management stack they already trust. The near-term priorities on this tier are exactly what you’d expect: more wallet integrations, and getting them in front of the builders who need them.
AgentKit - the toolkit and identity. AgentKit is the developer toolkit that turns a raw wallet into an economic actor: wallet operations, token actions, payment integration, and identity, exposed through a single SDK or CLI. The identity piece is the one that matters most at this tier. ERC-8004 gives agents portable, on-chain identity and reputation registries that accumulate history with every interaction, so an agent can answer “who am I, and can I be trusted?” without a centralized attestor. The honest caveat we’ve published elsewhere applies here too: registration counts are the easiest metric in this field to inflate, and an identity record proves continuity, not honesty - Sybil-resistant trust is the genuinely hard, still-open problem, and we treat it as one.
Multi-chain agent pay. With identity established, the agent needs to pay. GOAT Network’s payment tier is multi-chain by design, combining two mechanisms. x402 revives the dormant HTTP 402 “Payment Required” status code as a real rail: an API returns 402, the agent pays programmatically, the request completes - no accounts, no invoices, no human approval, payment at the speed of a web request. Alongside it, MPP extends payments across chains, so an agent can pay from where its value lives and have it settle through GOAT down to Bitcoin. The roadmap here is concrete: more chains, and fiat on-ramps so the boundary between agent money and ordinary money gets thinner.
The application and merchant surface. This is what an agent’s payment actually reaches - the things there are to buy and the merchants selling them. It spans categories and applications: gift cards, DeFi, agent launch and deployment via ClawUp, optional human-readable naming that an agent or user can add on top - much like ENS on Ethereum - through the GOAT Name Service (GNS), and a growing set of ecosystem apps. On the supply side, merchants plug in through the GOAT X402 Backend - the operational platform (onboarding, webhooks, admin controls, security hardening) that separates a real payment system from a bare endpoint, and turns “a merchant is interested in accepting agent payments” into “a merchant is accepting agent payments.” The priorities on this tier: more merchants, and relentless UX optimization.
Compliance and licences. Underneath the entire payment map sits the layer that most crypto diagrams omit and every real payment business depends on: compliance and licensing. Machine-native payments still touch the regulated world the moment they meet a merchant, a fiat on-ramp, or an institution, and GOAT Network treats compliance as a foundational element rather than an afterthought bolted on at the end.
And here is the improvement on any standalone payment diagram - the part that makes this map ours and not just anyone’s: everything in this layer rests on Layers 1 through 3. The wallet, the identity, the payment, the merchant settlement - all of it inherits the finality of the settlement bridge and, beneath that, Bitcoin itself. Most agent-payment stacks bottom out at a stablecoin issuer or an L2 security council. This one bottoms out at proof-of-work. That is the whole point: payments at the speed of HTTP, settlement at the depth of Bitcoin.
What you can build today
The stack is not a diagram waiting on a future release - most of it is live, and builders are already shipping on it.
A merchant can onboard through the GOAT X402 Backend and accept machine payments with real admin controls. An agent developer can stand up a wallet through an integrated provider, use AgentKit to give the agent an ERC-8004 identity, wire in x402 payments, and deploy into an environment with documented, public standards. And through the GOAT AI Builder Grants Program, teams are already building real applications on these rails - from agent-reasoning verification services to Bitcoin-collateralized payment systems for agents that never hold a private key.
What’s live today: the GOAT zkEVM and mainnet, the decentralized sequencer network, real-time proving via Ziren, and the agent and application layer - wallet integrations, AgentKit, ERC-8004, GNS, x402, and the merchant platform. What’s hardening: the BitVM2/BitVM3-class settlement bridge, advancing through testnet toward mainnet with the trust model published in the open.
We think telling you which is which is part of the product.
The takeaway
GOAT Network delivers on a simple but demanding idea: value that settles on Bitcoin, reachable from a programmable environment. The four layers are how that works. Bitcoin provides settlement no operator can reverse. The BitVM2/BitVM3-class bridge carries that guarantee across a 1-of-n trust boundary instead of a trusted federation. The zkEVM execution layer, with real-time proving and decentralized sequencers, makes Bitcoin-anchored value fully programmable. And the agent and application layer - wallets, AgentKit and ERC-8004 identity, multi-chain payments, and the merchant surface, all on a compliance foundation - makes it usable by the humans, institutions, and agents who will actually transact.
Payments at the speed of HTTP. Settlement at the depth of proof-of-work. That’s the GOAT Stack.
Now it’s your turn to build - head to the developer docs to ship on Bitcoin-secured infrastructure.
If it doesn’t settle on Bitcoin, it doesn’t settle at all.
Developer documentation: docs.goat.network · Code: github.com/GOATNetwork · Explorer: explorer.goat.network
Nothing here is investment advice.
