How Ten Trillion Triangles Uses AccelByte to Power AI-Driven Development for Autogenesis

Ten Trillion Triangles is building Autogenesis, a competitive strategy game where players can attempt almost anything they can describe. Instead of choosing every action from a fixed menu, players explain what they want to do in plain language and a stack of AI agents works out whether the move is valid, how it resolves, what it changes, and what happens next. That creates exactly the kind of situations you would expect from a game with an open-ended ruleset.

During testing, one AI player figured out that occupying a territory only required placing something inside it, so it built a research academy in the ocean and opened access to sixteen more territories. Another realized the narrator was a named entity, summoned him into the game as an NPC, and turned him against the other players. In another match, a player sued God, won, and took control of the narration.

For a game developer, the funny part wears off quickly. Those are the cases your rules, backend, and QA process actually have to survive.

Autogenesis is ranked PvP, so the AI acting as referee cannot simply produce something that sounds plausible. It needs to apply the game's rules consistently enough that players can trust the outcome. Matches can run for as many as 150 turns and accumulate more than 100 million tokens of history, which also means the studio has to keep inference costs under control while supporting all of the standard systems an online multiplayer game still needs.

Ten Trillion Triangles built its own AI framework, TPipe, to handle the game-specific problem. What it chose not to build was the backend underneath it. That decision started years earlier with AccelByte. With Autogenesis, it has evolved into something more interesting. The studio is now using AccelByte's MCP servers, AGS CLI, and AI plugin on top of the backend platform alongside Hermes Agent and its own custom tooling so its development agents can understand the backend, interact with real environments, help configure and deploy services, and playtest the game against the same systems players use.

This is the next chapter of Ten Trillion Triangles' relationship with AccelByte: moving from a backend the team does not have to build to a backend its AI-driven development workflow can actively work with.

“I've been impressed with how fast AccelByte is building out infrastructure to handle the massive shifting landscape AI has brought into game development. Most platforms, and even game engines are struggling to adapt to this.”

— Cage, Lead Engineer, Ten Trillion Triangles

The Challenge

Autogenesis is an unusual game, but many of the engineering decisions behind it start with a familiar problem. A small game team has a finite amount of engineering capacity. Every week spent building identity, persistence, matchmaking infrastructure, dedicated-server orchestration, admin tooling, or deployment systems is a week not spent on the systems players will actually experience.

That trade becomes even sharper when the game itself already has an expensive technical problem to solve. Ten Trillion Triangles runs smaller 9B and 30B class models through AWS Bedrock because using frontier models across a 150-turn match would make the inference economics difficult to sustain. The studio's work is therefore not simply "add AI." It has to get reliable game behavior out of models that are affordable enough to run at scale.

TPipe is where Ten Trillion Triangles spends its engineering effort on that problem. The framework handles the agent orchestration, game-specific governance, memory, and the systems needed to make AI-driven gameplay reliable enough for a competitive game.

The studio did not want the same engineers rebuilding a backend platform at the same time.

Why AccelByte Was Already in the Stack

This was not the first time Ten Trillion Triangles had made that call.

When the team was developing Revolution, its competitive card game, it needed the normal online-game stack: authentication, player collections, currency, social systems, matchmaking, and dedicated servers. The studio estimates that recreating those systems internally would have required roughly two additional years of work, around $350,000 in development cost, and two additional engineering hires.

Instead, it chose AccelByte. That let the studio keep its backend off the build list while still having the systems required to ship and operate an online game.

Autogenesis follows the same philosophy, only with a much more ambitious technical scope.

Ten Trillion Triangles has built TPipe. It is building its own browser-first game technology. It has written the game-specific systems that make Autogenesis unusual. Those are areas where the team wants to own the implementation because they are part of what differentiates the game. Authentication, persistent storage, multiplayer infrastructure, and server orchestration are not.

“AccelByte has made it largely possible and affordable for us to do this, because there's so much that goes into the backend of this game. There's matchmaking. There's a lot of complex cloud storage, which is a big one. We need centralized servers at an affordable cost, and to be able to adjust the rate of those servers quickly in real time. These are non-trivial things.”

The difference with Autogenesis is that AccelByte is no longer only infrastructure sitting underneath the game. The platform has also become part of the studio's AI-driven development workflow.

The Gap Between an AI Agent and a Backend

Ten Trillion Triangles uses Hermes Agent, the open-source agent from Nous Research, as part of its development environment. The studio has extended Hermes with its own skills, scripts, game-control tooling, and testing workflows for Autogenesis.

That distinction matters because a capable coding agent can already do a lot inside a repository. It can read unfamiliar code, generate an integration, write tests, refactor systems, and produce an API request that looks correct. Game backend work does not stop at producing a file, though.

An agent can write a login implementation without knowing whether it can actually authenticate against your development environment. It can generate a matchmaking request without being able to verify that the session was created. It can write code against an API while missing the namespace, permissions, configuration, or backend state that determines what happens when that code runs.

Anyone who has integrated an online game has dealt with this gap. The code can be correct and the system can still be wrong. Without access to the backend, every one of those checks eventually lands back on a human engineer. Someone opens the documentation, checks the Admin Portal, looks at the namespace, runs the request, inspects the result, and gives that context back to the agent.

Ten Trillion Triangles wanted Hermes to stay in the loop for more of that work.

That is where AccelByte's AI tooling started to matter.

MCP Gives the Agent the Backend Context It Was Missing

Ten Trillion Triangles makes heavy use of the AccelByte MCP servers to give its agents structured information about the actual backend they are working against.

Instead of asking Hermes to rely on whatever AccelByte knowledge happens to exist in the underlying model, the MCP server exposes the real API surface. The agent can find an operation by what it is trying to accomplish, inspect the schema, understand the required parameters and authentication, and reason about the response the backend will return.

For backend development, this is a particularly clean fit because the structure the agent needs already exists. APIs have defined operations, request and response shapes, authentication requirements, and machine-readable contracts because game clients have always needed them.

Cage describes the difference this way:

“MCP servers are being kind of bolted onto older game engines like an afterthought, often in cases where the engine just isn't equipped for it. It's not all like a backend where it fits cleanly because the API surface and contract was there to begin with.”

The value for Ten Trillion Triangles is not that Hermes can search documentation faster. It is that the backend context becomes available inside the same workflow the agent is already using for the game.

“We actually use the MCP server quite heavily to make the connections to AccelByte. We used it to build a whole workflow with our agents that allows it to set up everything. We were able to build login and everything through it, and then basically drive the game in real time and test for us.”

That moves the agent from making a plausible guess about AccelByte to working with the backend AccelByte actually exposes.

The AGS CLI Turns Backend Context into Backend Actions

Understanding the backend still leaves one more step. The agent needs a reliable way to operate it.

Ten Trillion Triangles uses the AGS CLI as that execution layer. The team has wrapped CLI operations into its Hermes skills so backend work can happen from the same terminal-driven workflow as the rest of development instead of having to stop, open the Admin Portal, make a change manually, and then hand control back to the agent.

The relationship between the two tools is straightforward:

1. MCP gives Hermes enough context to understand the backend operation it needs.

2. The AGS CLI gives it a deterministic way to carry that operation out.

This is particularly useful for tasks that sit around the code rather than inside it: setting up backend resources, working with environments, deploying into Extend or AMS, and moving toward more automated infrastructure management.

Ten Trillion Triangles is also working toward using agents to manage more of the AMS lifecycle, including reducing capacity when nobody is playing. That matters for Autogenesis because the expensive part of a match is already inference. The team does not want idle server capacity becoming another unnecessary cost when the game is quiet. Most multiplayer infrastructure discussions are about scaling up. For this project, being able to scale back down is just as important.

The AI Plugin Makes Those Patterns Reusable

AccelByte's AI marketplace plugin packages our MCP and CLI capabilities together with reusable skills for AI-assisted backend development. Cage actually found the plugin after Ten Trillion Triangles had already spent time building similar skills around Hermes. Once he tried it, the overlap made it easy to integrate into the studio's existing workflow. The important architectural distinction is simple.

Nous Research provides Hermes Agent. Ten Trillion Triangles has built the Autogenesis-specific development and testing workflow around it. AccelByte provides the backend context, execution surfaces, and reusable backend skills that plug into that workflow.

The result is not an "AccelByte AI agent." It is a studio-owned development workflow that can work with AccelByte without requiring a human engineer to translate every backend operation for it.

From Writing the Login Flow to Playing the Game

The best example of that difference is Ten Trillion Triangles' QA workflow.

Hermes can authenticate through the real AccelByte login flow and start Autogenesis against the same backend services the game client uses. Ten Trillion Triangles' own game controller then lets the agent drive the client and play rounds against the game's AI opponents.

While the match is running, the workflow also watches the JDWP debugger, reads logs, and works with the studio's testing layer. When something goes wrong, Hermes can move from gameplay into debugging without waiting for someone to manually reproduce the entire scenario.

The agent can recreate the failure, write a regression test, make a code change, verify it against the test, and then run another sequence of rounds to see whether the fix affected something else. From there, the same development environment can use the AccelByte tooling as part of the path back toward deployment. The loop looks much more like the workflow of an engineer than an AI coding assistant:

In Cage's own words:

“The AI agent setup and AccelByte's AI capabilities have made automated testing possible in a way I never thought would end up happening in my career as an engineer. We're able to literally have an agent playtest the entire game and do QA bug catching runs in real time.”

For Autogenesis, that is a perfectly good fit. There is no complete matrix of possible player actions because open-ended actions are the point. The team needs to discover interactions it did not think to write down ahead of time. A development agent that can keep playing against the actual game gives the studio another way to find those cases.

This is also where the distinction between "AI coding" and "AI-driven development" becomes useful. Generating a function is one step. Logging into the real environment, exercising the system, inspecting the result, fixing the problem, and running it again is a workflow.

That is the part Ten Trillion Triangles has been pushing toward.

The Backend Makes the Agent Workflow Useful

The AI workflow sits on top of a real multiplayer backend, and that matters.

The main Autogenesis game server is a Kotlin/JVM process running on AccelByte Multiplayer Servers. It keeps the match together, orchestrates TPipe's agent turns, and sends inference requests to AWS Bedrock. AccelByte Gaming Services provides the systems including identity, sessions, matchmaking, and Cloud Save, while AccelByte Extend gives the studio somewhere to run the server-side logic that is unique to Autogenesis.

Because those systems are already in place, Hermes is not being wired into a toy backend built purely for an AI demo. It is interacting with the same backend architecture the game itself depends on. Ten Trillion Triangles has also pushed those services into some interesting game-specific uses:

Cloud Save as Durable Memory for a Long AI Match

A long Autogenesis match contains a large amount of agent memory and game state. Ten Trillion Triangles serializes that information into Cloud Save, leaving a durable snapshot outside the individual AMS process running the match.

If the server hosting the game disappears, the match does not necessarily disappear with it. The persisted state gives the studio a way to reconstruct what the agents knew and where the game had reached. Cloud Save was not designed specifically as storage for the working memory of an AI-driven match. The service provides persistence, and Ten Trillion Triangles adapted that persistence to a new kind of game state.

That is exactly the sort of implementation flexibility the studio needed.

Extend Lets Matchmaking Account for AI Economics

Ten Trillion Triangles also runs a custom matchmaking service in Extend. For most multiplayer games, matchmaking is primarily about the player experience: skill, latency, region, queue time, party composition, or some combination of them. Autogenesis adds another variable.

Different matches can have different inference economics depending on the players involved, their subscription tier, and whether they bring their own Bedrock API key. The studio's custom matchmaking logic can account for those differences when constructing matches, effectively making matchmaking part of how the game manages AI cost.

We did not design AccelByte matchmaking around token economics. There would have been little reason to. Extend gives Ten Trillion Triangles somewhere to implement that game-specific requirement without modifying the platform itself.

This is an important part of the AI story because AI-native games will create backend requirements that did not exist when most online-game platforms were designed. The platform does not need to predict every one of them. It needs to leave the studio room to implement them.

Removing Work from Browser Architecture Too

Autogenesis is browser-first, which originally meant Ten Trillion Triangles needed an AWS gateway and Lambda function to bridge browser gRPC-web requests into its Extend services because AGS did not yet expose the CORS configuration the studio needed.

The workaround functioned, but it added another service, another network hop, another place to debug failures, and another piece of infrastructure to operate. When self-service CORS configuration became available in AGS, Ten Trillion Triangles removed the Lambda layer.

Before, the browser client reached Extend through an AWS gateway and Lambda function that bridged every gRPC-web request. After self-service CORS configuration in AGS, the client talks directly to AccelByte services and to Extend, with only security-sensitive calls routed through Extend on purpose.

“We were able to drop the lambda hops with cors up. The client is now able to talk directly to services using typescript, and is able to talk directly to extend. Some things we have to route to extend for security/anti-cheat reasons. But we can now make that initial hop and offload things like record pulls to the client.”

For a small studio, these reductions add up. The same team building TPipe, Autogenesis, its game technology, and its agent workflows has one fewer service sitting in the middle of every browser request.

What AI-Driven Development Has Changed 

Ten Trillion Triangles says it had a working, testable version of Autogenesis in roughly one month. Cage estimates that reaching the same point using Unreal would have taken four months or more.

About one month to a working, testable Autogenesis build, against Cage's estimate of four or more months to reach the same point in Unreal, labeled as a self-reported studio estimate.

“We had a working game for Autogenesis in about a month's time. If I made it through unreal just to get to the point of testing the game it probably would have taken around 4+ months.”

That is Cage's estimate, not an AccelByte benchmark, and the comparison reflects the studio's broader technology choices rather than the backend alone. The more useful takeaway is the amount of scope the team has been able to carry.

The platform removes the need for Ten Trillion Triangles to build and maintain the standard backend foundation itself. The MCP servers, AGS CLI, and AI plugin then reduce the amount of manual work required for the studio's agents to interact with that same foundation.

For us, that is the more meaningful version of AI-assisted game development. It is not just an assistant generating another block of integration code. It is an agent that can understand the backend, work against a real environment, start the game, play it, find something strange, and keep working from there.