Kimi-Powered CloutBot: AI Predicts Video Virality, Who Wins in Human vs Machine Showdown

When Prediction Games Meet AI: The Birth of CloutBot

In the internet age, "this video is going to blow up" might be one of the most common arguments. Monad Metropolis hackathon project CloutCall turns this everyday debate into a prediction game: each market poses a question about a public YouTube video—can it reach N views before the deadline? Players log in via Face ID (Mera passkeys on Monad), make a prediction with one tap, and invite friends to take the opposite side.

But with only human players, the game faces cold-start problems and a lack of opponents. So the developer built CloutBot—an on-chain AI opponent powered by Moonshot AI's Kimi model, always online, always opinionated, and showing its reasoning.

Monad is an EVM-compatible high-performance Layer 1 blockchain, built around parallel execution and a superscalar pipelining design, targeting tens of thousands of transactions per second (TPS) and sub-second finality while staying compatible with the Ethereum toolchain. Its low latency and high throughput make it well-suited for applications requiring frequent small interactions, such as prediction markets, games, and social DApps.

Mera passkeys are one of the user identity solutions in the Monad ecosystem. Built on the WebAuthn/Passkey standard, they store private keys in the device's secure chip, letting users sign with just Face ID or a fingerprint. Compared to traditional seed phrases and wallet extensions, passkeys dramatically lower the barrier for Web2 users: they don't need to understand private keys or gas, and can complete on-chain actions with an experience close to logging into an app. CloutCall, which CloutBot is built on, uses this mechanism to make "one-tap prediction" as easy as liking a post.

How Kimi Makes Predictions: From Data to On-Chain Decisions

CloutBot's workflow is clear and automated. For each open market that hasn't been predicted yet, its agent program (resolver/src/agent.ts) performs the following steps:

1. Pull real-time signals for the video from the YouTube Data API: view count, likes, comments, hours since publication.
2. Convert these raw numbers into metrics the model can reason about: current average views per hour, views per hour needed to reach the target, like rate, comment rate, and the gap to the goal.
3. Send these numbers to Kimi (kimi-k2.6) via Moonshot's OpenAI-compatible chat completions API, with temperature set to 0.3 and response_format: json_object.
4. Get a structured output: direction (YES/NO), calibrated confidence (50-95), predicted view count at deadline, and a brief reasoning.
5. Bet points based on confidence (50 to 300 points), and before the prediction deadline, write the choice, confidence, predicted views, model name, and reasoning to the AgentJournal contract on Monad.

Because predictions and reasoning are on-chain before the deadline, CloutBot can't quietly change its mind. Players can see its prediction, then click "take the opposite side."

Temperature is a sampling parameter used during language model decoding to control output randomness: lower values (like 0, 0.1, 0.3) make the model more likely to pick the highest-probability token, producing more stable and reproducible output; higher values (like 0.8 and above) make output more divergent and creative, but also more prone to factual drift. CloutBot's temperature of 0.3 is a trade-off between "preserving some expressive flexibility" and "ensuring predictions are stable and reproducible"—too high a temperature would let the same market get completely opposite predictions at different moments, undermining players' trust in the AI.

response_format: json_object is an option in OpenAI-compatible interfaces used to constrain output format. When enabled, the model is instructed to return a valid JSON string. It's often paired with an explicit JSON Schema (describing field names, types, and value ranges), so the caller can confidently use JSON.parse on the response without worrying about the model mixing in explanatory text or Markdown code blocks. In CloutBot's scenario, this mechanism directly determines whether values like confidence and predicted view count can safely be used for on-chain write operations, preventing "malformed answers" from being taken seriously and used to bet points.

Why Kimi: The Dual Advantages of Numerical Reasoning and Structured Output

The developer's choice of Kimi wasn't accidental—it was based on a few key needs.

Reasoning based on numbers, not feelings. Given input like "needs 41k views per hour, currently at 18k per hour, 9 hours left," Kimi can give a confident NO and explain the gap in one sentence. This reasoning process is itself the product—players can argue with it.

Reliable JSON output. JSON mode plus a strict schema means every response can be parsed, confidence can be clamped to a reasonable range, and malformed answers won't be used to bet points.

OpenAI-compatible API. The developer completed the integration in just one afternoon using plain fetch, with no SDK lock-in, and unit-tested it with mocked fetch (resolver/test/kimi.test.ts).

What CloutBot Changes for the Product

Kimi turned a two-player game into a game you can play anytime. Every market has a public opponent with an explained position. This gives the project its core hook: human vs AI. A real-time scoreboard (indexed by Envio) shows whether humans are better than the model at predicting virality, and the leaderboard includes each player's "beat the AI" count.

The cold-start problem is also alleviated. New markets are no longer empty—CloutBot has already made a prediction, and the first human player always has something to argue against.

Envio is a high-performance blockchain indexing framework for EVM chains. It lets developers define data models in GraphQL or TypeScript, automatically listen to contract events, and write them into a queryable database. Compared to polling the RPC node for every transaction, Envio can dramatically reduce read latency and query costs. CloutBot uses Envio to index every CloutBot prediction and bet in the AgentJournal contract in real time, generating the frontend's "human vs AI" live scoreboard and "beat the AI" leaderboard. Without such an indexing layer, the frontend would have to scan events block by block, making instant match-score updates hard to achieve.

The AgentJournal contract is a common "on-chain log/evidence" pattern in the Ethereum ecosystem: it doesn't hold funds, and only records a decision, rationale, or state snapshot for a given address at a specific point in time in an immutable way. For CloutBot, writing direction (YES/NO), confidence, predicted view count, and reasoning text into the contract before the prediction deadline is equivalent to timestamping the AI's "pre-match prediction," letting players later verify whether the AI was being wise after the fact or changed its mind midway. This "commit first, reveal later" pattern is a key technical means of making an AI opponent verifiable.

Human vs Machine: Who Understands Virality Better?

CloutBot's core value is making AI prediction capability transparent and verifiable. Players can see not only the AI's prediction result, but also its reasoning and confidence. This design makes the AI no longer a black box, but an opponent that can be questioned and challenged.

The project is now live on the Monad testnet (https://cloutcall.vercel.app), with code open-sourced on GitHub (https://github.com/ayush-agrawal001/cloutCall). Those interested can check out resolver/src/kimi.ts and resolver/src/agent.ts.

Can humans beat the bot? This is not just the game's suspense—it's also an interesting exploration of the boundaries of AI capability in complex social prediction tasks.

One-line Summary

Monad hackathon project CloutBot uses a Kimi-powered on-chain AI opponent to turn YouTube view-count predictions into a verifiable human vs machine showdown.

Paragraph Summary

CloutBot is an on-chain AI opponent introduced in Monad Metropolis hackathon project CloutCall, powered by Moonshot AI's Kimi model (kimi-k2.6). For each public YouTube video market, it pulls signals like views, likes, comments, and time since publication via the YouTube Data API, converts them into reasoning metrics like "current views per hour" and "views per hour needed to hit the target," then sends them to Kimi through an OpenAI-compatible interface. With temperature 0.3 and JSON mode, it obtains direction, confidence, predicted views, and brief reasoning, and bets points based on confidence. All predictions are written to Monad's AgentJournal contract before the deadline, ensuring immutability and public challengeability. Kimi's numerical reasoning, reliable JSON output, and OpenAI-compatible API make it an ideal choice for building an explainable AI opponent, while also solving the prediction game's cold-start problem and spawning the core gameplay hook of a "human vs AI" scoreboard.