GAME NOTES

Designing Koban Flip: every face is fixed when you buy the coin

Illustration for “Designing Koban Flip: every face is fixed when you buy the coin”
Koban Flip is a call-the-face game on an Edo-period gold coin: pick omote (front) or ura (back), and a correct call multiplies the pot by ×1.96. You can cash out after any win or ride the streak, up to ten flips, for a ladder that tops out at ×836.68. The coin is fair, each face has probability one half, and the house edge is exactly the gap between ×2 and ×1.96: 2% per flip, which is also 2% of the whole ride however long it runs. The design choice that matters most is invisible at the table: one ride is one seed pair and nonce, and flip i is derived from cursor i, so every face of the ride is fixed the moment the first coin is bought. Your calls decide whether you win; they never decide what the coin shows, and after the seed is revealed all ten faces can be recomputed whether you saw them or not.
BETKYO RESEARCHPUBLISHED 2026-09-11UPDATED 2026-09-117 MIN READ

The price of a fair coin

A fair coin paid at even money is a game with no edge, and a game with no edge cannot pay for the room. Every coin-flip game on every site solves this in one of two ways: it makes the coin unfair, or it pays less than ×2 for a correct call. The first is invisible and the second is not, which is the whole reason to prefer it. Koban pays ×1.96.

The arithmetic is short. A correct call has probability one half and returns 1.96 units per unit staked; an incorrect call returns nothing. Expected return per flip is 0.5 × 1.96 = 0.98, so the house keeps 2% of each flip. Because the pot of a ride is the stake multiplied by 1.96 for each win, and each win has the same probability, the expected return of a ride of any length is 0.98 raised to that length, and the edge on the whole ride, measured per unit of exposure, stays at 2%. Riding is not a way around the edge and not a way into a larger one; it is the same price paid more times.

ENGINE-VERIFIEDkoban/derive.ts: KOBAN_WIN_100 = 196 with the comment “×1.96 per correct call — a fair coin paid at 1.96 is a 2% house edge”; KOBAN_MAX_FLIPS = 10. _shared/demoLocal.ts demoKobanRide: the pot after each win is centsFloor(pot × 196 / 100); on a wrong call the round ends with payout 0; at ten flips the pot is credited automatically.

The ladder

Ride ten times and the pot has been multiplied by 1.96 ten times. The ladder the table shows is that power, floored to two decimal places at each rung, because the server settles the pot in cents and a displayed rung must match what would actually be paid. An unfloored 1.96 to the third power reads 7.53; the pot after three wins is 7.52. The engine comment records that the display once overstated six of the ten rungs by a cent before the floor was added.

The Koban ladder: cumulative multiplier after n straight correct calls, floored to cents
WINSMULTIPLIERCHANCE OF REACHING IT
1×1.961 in 2
2×3.841 in 4
3×7.521 in 8
4×14.751 in 16
5×28.921 in 32
6×56.691 in 64
7×111.121 in 128
8×217.791 in 256
9×426.871 in 512
10×836.681 in 1,024

Each rung is floor(1.96ⁿ × 100) ÷ 100. Multiply any rung by its chance and you get 0.98ⁿ, the expected return of a ride that goes exactly that far.

ENGINE-VERIFIEDkoban/derive.ts: the display ladder is Array.from({ length: KOBAN_MAX_FLIPS }, (_, i) => Math.floor(Math.pow(KOBAN_WIN_100 / 100, i + 1) × 100) / 100), with the comment that the server settles at floor(1.96ⁿ, 2) and “the ladder is a promise; it must match the pay”. The chances in the table are 1/2ⁿ for a fair face.

The right-hand column is the one to read. A ride to the top pays ×836.68 and happens once in 1,024 attempts, so its expected return is 0.817, which is 0.98 to the tenth power. Nothing on the ladder is a better or worse bet than anything else; the ladder is a volatility choice, exactly as the Limbo and Crash curves are, and the price of one more flip works the same rungs against a fair coin.

Fixed at the first buy

Here is the design decision that a player cannot see and should know about. A ride is not ten separate rounds. It is one round with one nonce, and the ten faces are ten cursors of that nonce: flip one reads cursor 0, flip two reads cursor 1, and so on. The whole sequence of faces exists, as a function of the seed pair and the nonce, the instant the first coin is bought. Riding does not draw a new coin; it reveals the next entry of a list that was already complete.

ENGINE-VERIFIEDkoban/derive.ts header: “One RIDE SESSION = one (seed pair, nonce); flip i reads cursor i, so every face in the streak is fixed the moment the first coin is bought — your calls decide wins, never the faces.” demoLocal.ts: demoKobanRide derives faces with deriveKobanFaces(serverSeed, clientSeed, nonce, picks.length) and compares faces[picks.length − 1] with the pick; the active round persists in localStorage so a reload cannot eat a pot mid-streak.

Why build it that way rather than one nonce per flip? Two reasons, and both are about what you can check. First, a ride that is one round can be verified as one object: reveal the seed and every face of the ride, including the ones after you cashed out, can be recomputed together, which is a stronger statement than verifying flips one at a time. Second, it makes a particular kind of dishonesty structurally impossible. A game that drew each flip fresh could, in principle, be built to draw differently once the pot was large; a game whose faces were all fixed before the pot existed cannot. The engine does not know how big your pot is when it decides the face, because it decided the face before you had one.

It also settles a question that the sister game, chō-han, raises in its own article: does your call matter? For the outcome, no. The face at cursor 4 is what it is; calling omote or ura decides whether that face pays you, not what it is. That is the same shape as the client seed, a lever that changes verification and never odds, and it is worth being clear-eyed about it before a streak makes the coin feel like it is listening.

The cash-out

The one decision that does matter is when to stop, and the engine gives it exactly one shape: after any win you may cash out the pot, or ride. There is no partial cash-out and no insurance, because either would move the edge somewhere less visible. Cashing out after n wins pays the nth rung exactly; riding risks the whole pot on a coin whose face is already on the list.

  • The edge does not change with the rung. Every flip costs 2% of what is riding on it. A big pot is not a reason to stop or to continue; it is only a bigger amount paying the same price.
  • Ten is the top. At the tenth win the pot is credited automatically, because the ladder ends and the engine does not offer an eleventh cursor.
  • A reload is not a reset. The active ride is stored, so closing the tab mid-streak does not forfeit the pot; the same faces are waiting when you return, because they never depended on when you looked.
The multipliers and rules above are read from the client derivation module and the demo engine, which the source describes as mirroring the house service; the house service is the paying authority. This is a design note, not a strategy: no way of calling or stopping changes the 2% per flip.
FAQ

What does Koban Flip pay?

×1.96 per correct call on a fair coin, compounding while you ride. The ladder after n straight wins is floor(1.96ⁿ, 2 decimals), from ×1.96 to ×836.68 at ten wins.

What is the house edge?

2% per flip: a correct call has probability one half and pays 1.96 instead of 2. A ride of n flips has expected return 0.98ⁿ, so the edge per unit of exposure stays 2% however far you ride.

Are the faces decided as I ride?

No. One ride is one seed pair and nonce, and flip i is derived from cursor i, so every face is fixed when the first coin is bought. Your calls decide whether a face pays you, never what it shows.

Can I verify a ride?

Yes. After the server seed is revealed, all faces of the ride can be recomputed from the seed pair and nonce, including flips after you cashed out.

What happens at ten wins?

The pot is credited automatically at ×836.68 of the stake. Ten is the maximum ride length; there is no eleventh cursor.

SOURCES & REFERENCES
  • Betkyo engine source: koban/derive.ts (KOBAN_WIN_100, KOBAN_MAX_FLIPS, the floored ladder, deriveKobanFaces), _shared/demoLocal.ts (demoKobanBuy, demoKobanRide, demoKobanCashout)
  • The ladder values are floor(1.96ⁿ × 100) ÷ 100 for n = 1…10, computed for this article and matching the engine’s display function
THE GAMES IN THIS ARTICLE
Betkyo Research — written by the team that builds these games. Every probability quoted in the Journal is derived from our engine source or a cited reference, never copied from another site. Figures are re-checked whenever the engines change.

18+ · PLAY RESPONSIBLY · THE JOURNAL IS EDITORIAL CONTENT, NOT BETTING ADVICE