Genome introduces GameFAI, merging AI with GameFi , to create smarter, more dynamic gaming ecosystems. Whether you're a developer or a player, you can utilize AI agents. As a developer you can enhance player engagement, development capabilities, and economic opportunities. As a gamer you can optimize your gameplay by analyzing your performance and refine your strategies.

AI driven agents optimize gameplay by analyzing performance, refining strategies, and automating tasks like resource farming and P2E mechanics. Players can also deploy AI in tournaments, prediction markets, and competitive battles, expanding the scope of gaming competition.

GameFAI introduces new revenue streams by allowing users to rent, sell, or deploy AI agents as virtual coaches, analysts, or autonomous players. This transforms skills and strategies into tradable assets, enriching the gaming economy and building on the Axie scholar system with something more tangible and sustainable.

To ensure fairness, Genome integrates Trusted Execution Environments (TEE) to verify AI interactions, ensuring transparency and security in competitive settings.

GameFAI enhances gaming across genres, from AI driven coaches to real-time esports predictions. By combining AI with GameFi, Genome pioneers a smarter, scalable, and sustainable future for gaming.

Genome's behavioral intelligence layer, Splice, unlocks InfoFi, a new layer of infrastructure that gives meaning to attention. It’s how apps, games, and protocols move beyond clicks and wallets to understand what users actually do and reward it.

With Splice, engagement isn’t just tracked. It’s scored, analysed, and used to shape smarter campaigns that grow with your community.

For builders, this means better retention, personalised rewards, and clear signals about what works. Run quests, launch tournaments, or evolve campaigns in real time, all based on real behaviour, not guesswork.

For users, it means what you do finally counts. Watching, playing, sharing, completing missions, it all builds toward something. Your actions unlock rewards, boost your status, and build your presence across projects.

Splice learns from every interaction. It adapts, segments, and improves how teams connect with their users. Using AI, Splice's InfoFi capabilities brings context to engagement and turns attention into something you can actually build on.

Web3 is growing rapidly, but it lacks the infrastructure to understand, grow, and retain new and existing users. Many studios face the challenge of turning attention into meaningful, measureable, and retainable growth.

Genome solves these problems by turning engagement into programmable, lasting value. Our approach adapts to user behavior in real time, rewarding high value actions and creating persistent value flows between platforms and people.

We're creating the foundation for InfoFi, an intelligent, scalable infrastructure in a single programmable layer that captures, scores, and rewards real user behavior across any platform.

This foundation powers persistent, engagement across all chains, apps, games, protocols, and campaigns. It transforms how you attract and retain users, and measure value.

What sets Genome apart:

Led by CEO Jason Loveridge (Founding Team of Pixelmon) and Product Lead Mile Gramatikov (Founder and CEO of M-Tech Entertainment), Genome is an ecosystem where players, developers, and AI agents thrive. Since launching in Q4 2024, we have garnered 350,000+ registed users and processed 1,000,000+ testnet transactions across 8+ blockchains; integrated AAA titles, including Counter Strike, Mobile Legends, Dota, and more; and established 100+ partnerships with industry leaders, such as BNB, Mantle, IMX, and top Web3 studios.

Genome isn’t just about innovation—it’s about providing a fully interconnected infrastructure for everyone. In this space, competition fuels opportunity, and every participant has something to gain.

As part of our mission, we're working with studios to launch scalable tournaments, questing systems, AI driven challenges, and monetization tools. Early adopters can secure their place in a growing ecosystem, where participation leads to lasting rewards and future opportunities.

Genome is pioneering a new era of competition where AI powered agents drive high stakes, autonomous gameplay. Unlike traditional scripted bots, these AI competitors adapt, strategize, and evolve in real time, creating a dynamic environment where human and AI intelligence collide.

Inspired by the concept of ‘Robot Wars,’ players and developers can deploy AI driven agents in automated tournaments, AI vs AI battles, and hybrid PvP experiences. These agents continually refine their tactics, optimizing their performance and pushing the limits of in game mastery, ensuring that competition remains fresh and scalable.

For developers, the ability to introduce their own AI agents into the mix opens up a world of possibilities. They can compete, learn, and adapt alongside others, while unlocking new monetization opportunities, whether it's training, trading, or renting out AI competitors. Players, too, benefit from the challenge of facing evolving AI opponents, allowing them to test new strategies, craft their own AI challengers, and deepen their gameplay experience.

This is more than just AI assistance, it's AI as the competitor, reshaping what skill and competition mean in the world of gaming. This is GameFAI.

Gaming is a market untapped by players and developers alike. Traditionally, each game operates within a closed ecosystem, accessible to a limited number of players and stakeholders, like sponsors. These economies are closed and only serve to favor large studios and AAA titles, leaving indie developers and smaller studios struggling to break through.

Here’s where Genome steps in to help create an open ecosystem that allows players and developers to participate in the economy, dismantling barriers by leveraging smart contracts and programmability to create a unified and accessible gaming ecosystem.

Genome's ecosystem provides the necessary tools and platforms to gamify and understand progression, statistics, and user behaviors. It rewards players for participation, enhancing engagement with meaningful incentives.

Moreover, Genome allows the developers to remain in full control. Integrate native game tokens and NFTs or gamify and enhance asset utility with custom logic such as fee burns. Genome surpasses traditional solutions, creating flexible and inclusive opportunities for all types of developers and games.

The NOME token plays a foundational role in the Genome ecosystem. It powers GameFAI and InfoFi interactions, enables players to deploy, train and monetize AI agents while supporting engagement and governance within Genome’s ecosystem.

Genome is powered by its own interoperable Layer 2 providing ultra fast omnichain connectivity, scalable infrastructure, and AI enhanced monetization, enabling developers, players, and viewers to capture tangible economic value while increasing DAUs (Daily Active Users) and DAVs (Daily Active Viewers) for integrated games.

Kode

Kode is Genome’s universal SDK that enables games to integrate programmable competition instantly through simple API integration. With chain and account abstraction, developers can enhance engagement and drive revenue without complexity.

Kode’s game agnostic API supports all gameplay formats, from singleplayer to score based challenges. Using WebSocket integration, Kode processes game results, executes payouts, and distributes revenue across any blockchain.

The modular Gateway allows developers to customize competitive environments, mixing and matching components for perfect integration. Kode supports native asset transfers like tokens and NFTs without wrapping, ensuring seamless interoperability across networks and unlocking true cross-chain gaming.

Kode comes with the following modules:

• Tournaments: Allow players to complete or house tournaments with customizable parameters and automated prize pool distribution.

• Predictions: Viewer speculation based on in game results and gameplay with live streaming.

Edge

Edge is Genome’s modular, whitelabel platform for questing, tournaments, predictions, badges, AI agents, live streaming, and gamified progression. Players can track progress, complete objectives, and earn rewards, driving engagement and retention.

With Privy powered account abstraction, onboarding is frictionless—automatically creating EVM and SOL wallets for users, eliminating blockchain entry barriers.

For developers, Edge provides the tooling necessary to capture attention, enhance engagement and improve retention. By combining modularity, instant onboarding, and interactivity, Edge powers scalable, evolving gaming ecosystems driven by player activity.

Splice

Splice is Genome’s behavioural intelligence engine that powers real-time engagement analytics across games, apps, and campaigns. It tracks how users interact, including clicks, completions, returns, and social activity, turning these actions into a clear and persistent engagement layer.

Splice moves beyond wallet-level data to measure actual participation. Every interaction contributes to scores like the Edge Score, which help tailor rewards, evolve campaigns, and improve retention through deeper insight.

For developers, Splice makes InfoFi work behind the scenes. It provides the data needed to understand users, personalise engagement, and connect attention to outcomes. By turning behaviour into strategy, Splice helps teams grow smarter and more effectively.

Inteligant

Inteligant provides agentic systems. It's the AI Hub of Genome and allows users to create the ultimate companion, unlocking new gameplay dynamics and enhanced user experiences.

Create AI agents that:

• Compete

• Automate Tasks

• Assist in Training

• Analyze Gameplay

• Predict

Powered with TEE validation, Inteligant provides fully autonomous and verified game states, enabling agents to interact with games in a trustless manner.

The Genome Edge Testnet is live here. Currently, we have support for 7 blockchains with more coming soon! If you need help or require specific blockchains please don't hesitate to reach out to us via the contact function on our website.

Available Blockchains

This page will describe the architecture of the game integration process with the Genome platform using KODE.

Game

1. Master Server

   • The master server is the central control unit for the game. It coordinates the activities and status of multiple game servers and communicates with platform.

2. Game Servers

   • These servers host the actual game instances. They handle the real-time gameplay and player interactions.

Genome Platform

1. Game API

   • The Game API is the primary interface through which the platform communicates with the game's master server. Connection is carried by WebSockets. The API includes several events:

   • startGame (Game API → Master): Initiates a new match on the master server.

   • gameStarted (Master → Game API): Notifies the platform that a match has successfully started.

   • gameEnded (Master → Game API): Indicates that a match has concluded.

2. Frontend

   • The frontend of the platform is responsible for managing player interactions with platform. One of the key functions shown in the diagram is:

     • Players Linking: This feature allows players to link their nicknames or identities within the platform to their game profiles, ensuring seamless integration and recognition across both platforms.

Communication Flow

• The flow of information begins with the platform's Game API sending startGame event to the game's master to start a match.

• Once the match is initiated, the master manages the distribution of the game instances across the game servers.

• The platform's frontend manages the linkage of player nicknames, ensuring that player identities are synchronized between the platform and the game. Linkage is initiated from game client, as shown on diagram.

• Throughout the gameplay, master notifies Game API about the match states (gameStarted and gameEnded), allowing the platform to monitor and manage game sessions.

On this page, you'll find detailed guides, API references, and technical insights to help you leverage Genome’s tools. Whether you're getting started or deep into development, our docs aim to offer the support you need.

Our team is hard at working on creating additional guides and examples, if you need assistance please reach out to us via the contact function on our website.

With the global gaming audience on track to reach 3 billion players, gaming has become a key driver of digital engagement, generating more revenue than the music and film industries combined. Valued at $455 billion, the industry is on track to reach $1 trillion in the coming years.

This growth is driven by several factors, including, smartphones, online gaming, high speed networks, and increasingly immersive 3D worlds, making games more accessible, social, and engaging.

Yet, despite its rapid growth, gaming faces major limitations:

Genome bridges these gaps with open, intelligent infrastructure that turns engagement into real value. By connecting games, protocols, and users through real time analytics, AI agents, and cross-chain tools, we’re building a future where attention becomes equity—and where players, developers, and agents all earn based on what they contribute.

Gaming should be open, interconnected, and designed for long term growth, allowing every participant to benefit—not just large studios. By bridging fragmented networks and introducing new economic models, Genome is building a future where players and developers have greater control, ownership, and earning potential.

This guide will walk you through integrating your game with the Genome API using KODE, enabling you to manage matches, players, and tournament information.

Prerequisites

• Node.js: Ensure you have Node.js installed on your system.

• API secret: You need a Genome personal secret to interact with the API.

• Game Server: You should have a server running your game, which can communicate with the Genome API.

• Basic knowledge of Node.js: Familiarity with JavaScript, Node.js, and asynchronous programming is recommended.

Setup

mkdir game-integration
cd game-integration
npm init -y

npm install --save socket.io-client jsonwebtoken dotenv zod
npm install --save-dev typescript ts-node nodemon

{
  "compilerOptions": {
    "target": "es2016",
    "module": "commonjs",
    "rootDir": "./src",
    "outDir": "./dist",
    "noEmitOnError": true,
    "esModuleInterop": true,
    "forceConsistentCasingInFileNames": true,
    "strict": true,
    "strictNullChecks": true,
    "skipLibCheck": true
  },
  "include": ["src/**/*.ts"],
  "exclude": ["node_modules"]
}

"main": "dist/app.js",
"scripts": {
  "build": "tsc",
  "start": "node ./dist/app.js",
  "dev": "nodemon ./src/app.ts"
}

# .env
GAME_API_URL=ws://localhost:2593
PLATFORM_URL=http://localhost:2594
GAME_ID=game_id_2
GAME_SECRET=game-1-secret

import { config } from 'dotenv';
import { z } from 'zod';
config();
export const Env = z
    .object({
        GAME_API_URL: z.string().url(),
        PLATFORM_URL: z.string().url(),
        GAME_ID: z.string(),
        GAME_SECRET: z.string(),
    }
    .parse(process.env);

import { z } from 'zod';
import { Env } from './environment';
export const GameId = z.literal(Env.GAME_ID);
export type GameId = z.infer<typeof GameId>;
export const PlayerId = z.string();
export type PlayerId = z.infer<typeof PlayerId>;
export const MatchId = z.string();
export type MatchId = z.infer<typeof MatchId>;
export const TournamentId = z.string();
export type TournamentId = z.infer<typeof TournamentId>;
export const AuthTokenPayload = z.object({
    gameId: GameId,
});
export type AuthTokenPayload = z.infer<typeof AuthTokenPayload>;
export const TeamScore = z.object({
    players: PlayerId.array(),
    scores: z.number().array(),
});
export type TeamScore = z.infer<typeof TeamScore>;
export const GameEndedEvent = z.object({
    matchId: MatchId,
    tournamentId: z.string().optional(),
    winners: z.record(z.number(), TeamScore),
});
export type GameEndedEvent = z.infer<typeof GameEndedEvent>;
export const GameStartedEvent = z.object({
    matchId: MatchId,
    tournamentId: TournamentId.optional(),
    timestamp: z.coerce.number().int(),
});
export type GameStartedEvent = z.infer<typeof GameStartedEvent>;
export const LinkTokenPayload = z.object({
    gameId: GameId,
    playerId: PlayerId,
    rating: z.coerce.number().optional(),
});
export type LinkTokenPayload = z.infer<typeof LinkTokenPayload>;
export const Team = z.object({
    players: PlayerId.array(),
});
export type Team = z.infer<typeof Team>;
export const StartGamePayload = z.object({
    matchId: MatchId,
    tournamentId: TournamentId.optional(),
    backUrl: z.string().url().optional(),
    rivals: Team.array(),
});
export type StartGamePayload = z.infer<typeof StartGamePayload>;
export const StartGameEvent = z.object({
    games: StartGamePayload.array(),
});
export type StartGameEvent = z.infer<typeof StartGameEvent>;

Establishing a WebSocket Connection

This chapter focuses on establishing a WebSocket connection with the Genome API, which is crucial for real-time communication and receiving updates.

import jwt from 'jsonwebtoken';
import { Env } from './environment';
export const signPayload = <T extends {}>(payload: T) => {
    return jwt.sign(payload, Env.GAME_SECRET, { algorithm: 'HS256' });
};

import { io } from 'socket.io-client';
import { signPayload } from './auth';
import { Env } from './environment';
import { AuthTokenPayload } from './models';
async function main() {
    const client = io(Env.GAME_API_URL, {
        auth: {
            token: signPayload(AuthTokenPayload.parse({ gameId: Env.GAME_ID })),
        },
    });
    client.on('connect', () => {
        console.log(`Connected to Game API`);
    });
    client.on('startGame', (_payload) => {
        throw new Error("not implemented yet")
    });
    client.on('disconnect', (reason) => {
        console.log(`Disconnected with reason: ${reason}`);
    });
}
main();

Handle API Events

In this part we explain how to handle the game start and game end events.

Replace content in main.ts with handler of game start and commitment of result logic.

For demonstration purposes, in the example code, we’re using a dummy implementation based on artificial delays, but you need to create your own game client to create matches and wait for results.

client.on('startGame', async (payload: unknown) => {
    const parsedPayload = StartGameEvent.parse(payload);
    console.log('start game', parsedPayload.games);
    await Promise.all(
        parsedPayload.games.map(async (game) => {
            // Dummy 1s wait for emulate game starting mechanics
            await sleep(1000);
            // Notify ZeroSum API about started game
            await client.emit(
                'gameStarted',
                GameStartedEvent.parse({
                    matchId: game.matchId,
                    tournamentId: game.tournamentId,
                    timestamp: toUnix(Date.now()),
                } satisfies GameStartedEvent),
            );
            // Dummy 1s wait for emulate game finishing mechanics
            await sleep(1000);
            // Construct random array of winners
            const winners = game.rivals.map(({ players }) => ({
                players,
                scores: players.map(() => Math.floor(Math.random() * 10000)),
            }));
            // Sort winners accordingly random scores
            winners.sort(
                (a, b) =>
                    b.scores.reduce((total, next) => total + next) -
                    a.scores.reduce((total, next) => total + next),
            );
            // Notify ZeroSum API about game ended
            await client.emit(
                'gameEnded',
                GameEndedEvent.parse({
                    winners,
                    matchId: game.matchId,
                } satisfies GameEndedEvent),
            );
        }),
    );
});

Start Game

1. Wait for astartGame event.

2. parsedPayload.games.map(async (game) => { Loop though all games and proceed with a match for each game:

   1. Create a match in the game (we’re just waiting 1 second: await sleep(1000))

   2. Emit gameStarted event to our api

await client.emit(
    'gameStarted',
    GameStartedEvent.parse({
        matchId: game.matchId,
        tournamentId: game.tournamentId,
        timestamp: toUnix(Date.now()),
    } satisfies GameStartedEvent),
);

End Game

1. Wait for results (we’re just waiting 1 second and create random scores and winners)

2. Emit gameEnded event to our api

await client.emit(
    'gameEnded',
    GameEndedEvent.parse({
        winners,
        matchId: game.matchId,
    } satisfies GameEndedEvent),
);

Linking Players

Game events operate with player IDs linked with the platform by your game server. Follow the steps below to link a user with the platform.

const payload = LinkTokenPayload.parse({
    gameId: Env.GAME_ID,
    playerId: <PLAYER_INGAME_ID>
} satisfies LinkTokenPayload)

const token = signPayload(payload)

redirect(`${Env.PLATFORM_URL}/?token=${token}`)