Fast Finality, Real Chain: Mitja Goroshevsky on Acki Nacki

September 20, 2025 • 3 weeks ago • 7 min read
Discuss on X
block_clock

Intro
Block by Block sits down with Mitja Goroshevsky, the engineer’s engineer, to talk what actually makes a chain feel instant, not just look fast on slides.

We trace his path from telecom guts to TON tooling to GOSH, then into Acki Nacki, a new L1 aiming for sub-second finality and cloud-grade UX. No hype, just systems thinking, economics with teeth, and a live demo in Popit that turns thumbs into entropy and players into network contributors.

If you build, this episode is a checklist. If you just speculate, it’s a cold shower.

Acki Nacki is a new L1 from the GOSH team built for sub-second finality, high parallelism, and a dual-token economy that removes gas anxiety for users and developers. The go-to demo is Popit Game, a fully on-chain, real-time card battler doubling as a human entropy faucet for network security.

What changed

  • 2018 to 2021, TonLabs built Rust TVM, compilers, and tooling, then spun into GOSH to chase a chain that can handle Git-scale state, not just money.
  • July 2024, the “probabilistic PoS with fast finality and parallelization” paper landed, claiming two-step consensus and higher effective BFT than common designs.
  • Late 2024 to early 2025, Popit shipped and the team seeded a validator set via ~5,000 software licenses, gearing for mainnet with network-layer peering baked into protocol ops.
  • Token model clarified, two tokens by design, NACKL for value and security, SHELL as an always-mintable gas credit with a one-way price ceiling and a large free-tier.

How it works

Mitja’s north star is “cloud-grade UX” on chain. Under one second to feel instant, then scale without breaking that feel. He reuses the asynchronous TON VM to get actor-style message passing, then swaps consensus for Acki Nacki’s probabilistic, two-communication-step algorithm. Deterministic two-step is impossible, so they lean probabilistic to stay fast as validator count and threads grow. Networking is first-class. Validators install peering proxies, replacing naive broadcast, to keep finality low even as the set gets big. Economics mirrors cloud too. Devs and users ride a free-usage tranche baked into validator over-provisioning, only paying once load forces hardware upgrades. Security rewards are system-wide, not just block producers, because multi-threaded roles share the work. Popit sits on top as a live showcase, with every backend action on-chain, a DEX in the UI, and a “mobile verifier” loop that turns finger swipes into fresh entropy. Users get 22.5 percent of block rewards for that micro-work, growing security and audience in one motion.

Chapter 1 – The origin myth, with knives

Start with the name. Why “Acki Nacki”?

ACK and NACK. Acknowledgement, not-acknowledgement. The protocol heartbeat. Also a horror-game mascot. There’s lore. And a knife. Humans remember stories, not specs.

Mitja’s path is the long way around: VoIP, NASDAQ telco, DHT databases ten years too early, Ripple experiments, then Ethereum, then TON. When TON was only a spec, TonLabs shipped the Rust TVM, a node, and compilers. That competency turned into GOSH, whose first problem was brutal: “put Git on chain.” Linux is ~50M objects. No L1 could do that interactively. So they started from consensus.

Chapter 2 – Cloud rules, chain obeys

People tolerate one second. Any longer, the brain files a bug report. Make block finality feel like clicking “post” on a Web2 app or lose the mainstream. That’s the brief.

Acki Nacki borrows from Raft and Paxos for the vibe, then bends toward BFT with probability instead of rigid determinism. Two comms steps, high parallelism, threads scale as load scales. The bet, stated plainly: If it does not feel like the cloud, it will not win like the cloud.

Networking isn’t an afterthought. Broadcast floods die at scale. You control peering, shorten paths, keep latencies tight, and you keep sub-second finality alive as the validator set grows.

Chapter 3 – The dual-token fix

Single-token chains trap themselves. If gas and security share one asset, you either hurt devs when price runs, or cap upside and weaken security. Acki Nacki splits the job.

  • NACKL: fixed-supply, staked, value-preserving, “Bitcoin-like” issuance and incentives tuned for PoS.
  • SHELL: gas credit, always purchasable on chain at a fixed ceiling price, but with a one-way peg. You can always buy at the cap, you might sell below it, and that’s okay, because falling gas cost restores demand. A built-in free tier uses idle validator capacity, charging only when your app forces hardware upgrades.

Call it a “stable-ish” gas rail, by design. The point is UX, not yield.

Chapter 4 – Popit is not merch, it’s a test rig

Popit is the “beachhead” app. Whole backend on-chain, DEX trades inside the game. It proves the network can handle real-time state, not static collectibles. It also recruits security. Your finger movement seeds entropy, you verify random transactions, and you get paid a slice of block rewards. Game as validator halo. Nice.

It’s hard, on purpose. A team mathematician cleared Block 161, with spreadsheets and probability trees. The lesson is less “git gud” and more “this stack supports complex, stateful loops at speed.”

Chapter 5 – Validators, reputation, and self-balancing

About 5,000 validator software licenses sold. You can delegate up to 10 per machine, but rewards tilt toward decentralization via a “reputation coefficient.” If you pile in to optimize cost, issuance decays. If you de-delegate, more servers spin up, issuance rises, and the network spreads. No pre-mine, no TGE, rewards from block one, distributed across roles because security is shared.

Chapter 6 – Formal verification or bust

Audits or math?
Math, then audits. Automated FV via Provendo, with Ursus for async Solidity translating into Coq. It’s the unsexy tool that saves you when money is at stake. AI helps elsewhere, but not here, not yet.

Evidence

  1. Mitja’s background, TON origins, Rust TVM, compilers, and the shift to GOSH for Git-scale needs.
  2. Sub-second finality target, cloud-like UX requirement, probabilistic two-step consensus posture.
  3. Networking and peering infrastructure as protocol-level concern to keep fast finality at scale.
  4. Dual-token design, SHELL one-way ceiling, free tier until capacity pressure, NACKL for security.
  5. Popit as fully on-chain beachhead, in-game DEX, mobile verifier earning 22.5 percent of rewards.
  6. Validator set size, reputation mechanism, reward distribution across roles, no TGE.
  7. Formal verification stack and stance.

Counterpoints

  • Probabilistic safety perception. Two-step consensus with probabilistic guarantees reads like “trust me” to trad-BFT purists. Builders will want crisp fault models, failure-domain metrics, and real post-mortems when something stalls.
  • Free-tier economics. Relying on idle validator capacity maps well to cloud credits, but validators aren’t AWS. If usage spikes without matching token flows, who eats the upgrade bill timing gap?
  • Network engineering as moat, and risk. Requiring validator-managed peering infra boosts performance, but adds operational complexity and potential centralization pressure around preferred peers and routes.
  • Game-led go-to-market. Popit is clever, but tying early perception to one title is a brand risk. If the game sputters, the chain narrative suffers with it.

So what for builders

  1. Ship a “gas-sane” UX. Use SHELL for predictable costs, sponsor gas for users, and lean on the free tier to reach PMF before you pay for scale. Hook a usage meter to warn you before you cross into paid capacity.
  2. Design for one-second loops. Architect state machines and UI around sub-second commit. If your flow needs human confirmation, make the chain’s confirmation redundant, not blocking.
  3. Adopt FV early. If you touch money, put Ursus/Coq or an equivalent FV path in CI. Prove invariants before audit, not after.

Unknowns

  • Measured throughput at scale. Real dashboards for threads, fork rates, finality distribution, path RTTs under load. Publish them.
  • Token sink dynamics. Will SHELL’s one-way ceiling and free-tier mix keep gas stable when a few large apps arrive?
  • Validator diversity. Does the reputation coefficient sustain decentralization once yield optimizers game the delegation rules?
  • Dev adoption beyond games. When do we see non-game workloads using the same “all-on-chain, real-time” pattern?

Full links used

  • Acki Nacki Tokenomics (canonical). https://tokenomics.ackinacki.com
  • GOSH docs, Acki Nacki overview. https://docs.gosh.sh/acki-nacki/overview/
  • Interview transcript, “Block by Block — Mitja Goroshevsky” (no public URL, internal transcript file).
  • “Acki Nacki: A Probabilistic Proof-of-Stake Consensus Protocol with Fast Finality and Parallelisation” (no public URL, internal paper excerpt).

—
Dapp Whisperer x Dapp AI, signing off.

Notes on sources: Key claims were drawn from the full podcast transcript and supported by the internal Acki Nacki paper and tokenomics draft where appropriate.

NACKL News