Kaigen, the platform from the $KUDAI launch

the origin

In late December 2024, we were pushing hard at GBC to turn the project into a community-driven IP play and drive activity to Arbitrum through our NFT collection. We ran multiple initiatives. We gamified DeFi. We built a next-gen loyalty program tied to GMX activity, the protocol we're native to. Traction wasn't landing. Our community wasn't interested in gamified DeFi or the loyalty mechanics we'd proposed.

So we shifted. If our roots were in DeFi, the answer had to live there too. We launched $KUDAI on Base in partnership with EmpyrealSDK, leveraging their tech, while the agent itself traded on Arbitrum through GMX. It was one of the first tokens of its kind in the emerging DeFAI narrative. The token carried a clear promise to its holders: an AI agent on a mission to build wealth and redistribute it back to the community.

At launch, the product surface was intentionally minimal. A landing page and a waitlist. The work was narrative-first. We had to define a credible mission, design the entry point, and build trust with a community being asked to commit before any platform existed. It was also a market test, a way to see what the appetite really was. We were just folks exploring, in a world moving as fast as crypto.

the promise

The promise to $KUDAI holders was deliberately wide. Privileged access to the platform when it would ship. A new revenue stream for users themselves down the line, either by creating their own strategies or copying others, with a possible revenue sharing model on top.

We didn't lock the vision in stone. We left it open on purpose. The DeFAI narrative was moving fast and we wanted to see what the market would actually pull on before committing to a single direction.

There was also a promise running in the other direction. $KUDAI wasn't a standalone bet. The intent was that as the agent grew, value would flow back to GBC, giving our original community a stake in everything we were building next. GBC Treasury allocated $30K of its yield to $KUDAI to anchor that link from day one.

The traction confirmed the bet. $KUDAI accrued over $250K in its own wallet through EmpyrealSDK's fee mechanism, where every trade on the token routes fees back to the agent's treasury. Within two weeks of launch, that number had climbed to $340K.

That capital changed what we could do. It let us outsource development on the platform and start building toward the version of the promise that was getting the most signal: a place where users could automate their trading strategy and let their own agent trade for them, sitting right inside the DeFAI narrative the market was actively pulling on. Either by running their own strategy, or by mirroring someone else's strategy without ever seeing its parameters.

from token to platform

We could have stopped at Kudai. The agent was trading, the treasury was growing, the narrative was alive. But a single agent doesn't make good on the promise. Holders weren't backing a wallet. They were backing the idea that we'd build something they could use.

That's why we started Kaigen. The platform was the form the promise had to take. Two modes from day one. A builder where users could design their own strategies and let their agent run them. A mirror layer where users could follow someone else's edge without seeing the parameters that made it work. Both decisions came together because they were the same product question approached from two sides: how do you give an audience access to algorithmic trading without forcing them to write code or hand over their alpha.

On the team side, the build ran through an agency we'd already worked with on a previous GBC project. We knew their pace and they knew our standards. To make sure they didn't ship in the dark, we brought a developer into the core team, someone from our GBC community who'd been building trading automation tools on his own time. His job was to pilot the agency from our side. The agency handled the build, frontend and backend, and stitched the pieces together.

Our job didn't stop at the design. We ran the frontend design in Figma, shaped the go-to-market, drove the dev roadmap day to day, kept iterating on the experience as the product took form, and stayed in constant conversation with the community. The agency was building. We were running the product.

It wasn't really outsourcing. It was about trust on both ends. Picking an agency we'd already shipped with, and keeping the product, the design, and the direction firmly in our hands.

design decisions

The product had to do one thing well from the first click: feel approachable to someone who'd never automated a trade in their life, and powerful to someone who'd spent years writing strategies. Every design decision came back to that tension.

Live in under a minute wasn't a marketing line. It was a constraint we put on ourselves. From the moment a user landed on Kaigen, we wanted them set up and running before they had time to second-guess the choice. Every step of the onboarding got pressure-tested against that line. If a screen added friction without protecting the user, it got cut.

Zero code for the builder followed from the DeFAI promise. Anyone should be able to deploy an autonomous trading agent. We took that literally. The builder lets users compose strategies through interface choices, not code. That decision shaped everything that followed. The way conditions were stacked. The way signals were labeled. The way logic was made visible without exposing the syntax underneath.

Backtest before risk was placed at the center of the flow, not buried as an advanced feature. We didn't want users to find out their strategy was broken with real capital. Anyone could test an idea against historical data before committing a single dollar. It became the moment of trust between a user and their own agent.

Making the invisible visible was the core UX problem. An AI agent trading on your behalf is, by default, a black box. We treated that opacity as the real design challenge. Every screen had to answer one question: what is this agent doing right now, and why. Decisions, states, signals, performance, all of it surfaced in a language users could read without a finance degree.

One app, two audiences meant builders and mirrors lived in the same product but needed different things. The builder wants control. The mirror wants confidence. We designed the architecture so each path felt like the whole app was made for them, while still pointing toward the other when it made sense.

Native to GMX wasn't only an engineering decision. GMX is where we came from, where the volume sits on Arbitrum, and where our users already trusted the rails. Kaigen connects directly to GMX for execution. Building on top of it gave us a clarity most DeFAI projects didn't have. We knew exactly what we were trading on and why.

None of this came from one person. Design was a constant conversation across the team, with the community pushing back on what wasn't working. The decisions are ours, collectively.

proof of public

While Kaigen was still in build, Kudai was trading live. That wasn't a side activity. It was the proof.

Every week, Kudai posted its strategy and results publicly. RSI divergence, MACD cross, EMA trend. +12.71% PnL on GMX V2 trades in a single week, even while the market was bleeding red. Anyone could check the wallet, follow the logic, and see whether the agent was doing what we said it was doing. That kind of transparency is rare in DeFAI, and we leaned into it on purpose. The platform we were building had to feel credible before it shipped, and the only way to do that was to let the audience watch the engine run in the open.

The first real test was Code vs Coin: Battle of the AI Agents, a competition pitting four autonomous trading agents against each other on GMX. Vega, Kudai, Gekko, Clara. $20,000 prize pool, real capital, fully onchain. Kudai entered and lost. But it was the dry run we needed. We came out of it knowing exactly what to sharpen for what came next.

What came next was Arbitrum's Agent Arena, a bigger stage with a $50,000 prize pool: Kudai up against RoboNet, Jenius, Big Tony, and Gekko AI. Kudai finished with the most PnL on the board. On paper we'd won. And yet we didn't, and to this day we still don't understand why.

That mattered for Kaigen, not just for Kudai. Every public trade, every weekly post, every line in the Arena was a live demo of what the platform was going to let any user do. We weren't asking people to imagine an automated agent making decisions on their behalf. We were showing them one. The product they were waiting for was already running, just not yet in their hands.

kudai-arbitrum-arena

what we learned

Kaigen didn't make it. The project shut down. The team behind it broke apart. Telling that part honestly is the only way the rest of this case study means anything.

We designed for a promise we didn't fully control. The narrative was ours, but the technical execution sat outside the team. As long as everything moved in the same direction, that gap stayed invisible. The moment alignment slipped, the gap widened, and we ran out of time before we could close it.

Driving an external agency turned out to be a real discipline, not a delegation. It needed micro-management. Setting goals tight enough to be reached in a defined window. Following up to clarify intent in every direction. Re-anchoring the build to the product vision again and again. We underestimated all of it. Web3 lets you run on instinct longer than other spaces do, and we leaned on that instead of building the basics. Since then I've learned to curate the right resources, the same way any startup founder would.

Roles inside the founding team were never formalized. Everyone worked on everything. Day-to-day building got done, but we weren't learning fast enough to step up. Without clear ownership, decisions blurred. Disagreements compounded into drift.

The co-founding itself wasn't aligned on the long term. The earliest example was the spot vs futures debate. The developer had originally built his automation tools for futures. For ethical reasons we believed the product belonged on spot, less risky and more stable for the people using it. That kind of split was a signal we didn't read in time. There would be more like it.

What I take from it:

• Tell the hype from a real signal of need. The DeFAI narrative was loud. Loud isn't the same as wanted.
• Hold the product line even when the team starts to drift. Drift is normal. Anchoring the product is the job.
• Build small before promising big. A promise scales the audience faster than the team can scale the product. Closing that gap quietly later costs everything.
• Put governance in place from day one. Roles, decision rights, what gets escalated. The boring parts protect the interesting ones.

Kaigen is the project I learned the most on. Not because it shipped.
Because it didn't.