AI and Gaming: How Agentic Tools Are Rewriting Game Creation

AI and gaming have been circling each other for years, but the relationship is finally getting interesting. The arrival of agentic tools — systems that don't just autocomplete a line of code but carry out multi-step creative work alongside you — is quietly rewriting how games get made. At ETAPX, we build one of those tools, Ocsidian, and this is our honest take on what changes, what doesn't, and why the difference matters more than the marketing suggests.

Let's start with a confession that the industry rarely makes out loud: most of game development has nothing to do with the game. It's pipeline. It's wiring a physics body to a mesh, fixing an import path, transcoding a texture, regenerating a navmesh after you moved a wall, restructuring a scene graph because the lighting looks wrong, and re-reading documentation you've read forty times before. The creative spark — the moment you imagine a world and want to walk through it — gets buried under hours of plumbing. Agentic AI is the first technology that genuinely attacks that plumbing without also flattening the creativity on top of it.

That's the thesis of this piece. Not that AI will "make games for you." It won't, and frankly you wouldn't want it to. The interesting story is more specific and more useful: agentic tools collapse the distance between intent and a playable result, they democratize who gets to enter the medium at all, and — this is the part the hype machine skips — they raise the value of human taste rather than lowering it. We'll walk through how this actually works inside Ocsidian's architecture, what gets democratized, what stubbornly resists automation, the real risks, and where we think the whole thing is heading.

What "Agentic" Actually Means in Game Creation

The word agentic gets thrown around until it means nothing, so let's pin it down. A traditional AI coding assistant is reactive. You type, it suggests. It completes the sentence you started. Useful, but it's a smarter autocomplete — it operates one keystroke ahead of you and has no model of the larger goal.

An agentic tool operates on intent. You describe an outcome — "give this level a stormy night mood with rain and flickering streetlights," or "make the player character double-jump with a short hang time at the apex" — and the agent plans, takes a sequence of actions, inspects the result, and iterates. It reads your scene. It understands that a streetlight is a point light with an intensity curve, that rain is a particle system, that a double-jump is a state in a movement script with a velocity reset and a timer. It composes those moves into a coherent change and shows you a result you can play.

The distinction sounds academic until you watch it work. Reactive AI shortens the act of typing. Agentic AI shortens the act of building. Those are not the same thing, and the gap between them is where the medium is being rewritten.

"The old measure of an editor was how powerful its tools were. The new measure is how short the line is between what you imagine and what you can play. That's the only metric we actually care about."

— ETAPX Product Team

Why a Game Engine Is the Hardest Place to Put an Agent

It's worth appreciating why game creation is a uniquely demanding home for agentic AI, because it explains why generic chatbots fall apart the moment you ask them to build something real. A game is not a document. It's a live, stateful, multi-system simulation. A change to a material affects how light bounces. A change to a collider affects how the player moves. A change to a script can break at runtime in a way that no static analysis catches, because the bug only appears when a physics body and an animation curve disagree at frame 600.

An agent that wants to be useful here can't just generate plausible text. It has to understand a scene graph, respect a physics solver, write scripts that compile and behave, and — critically — be able to run the result and look at it. That last requirement is why we built Ocsidian the way we did. An agent without a live preview is a writer who never reads their own work.

How Ocsidian Approaches Agentic Game Creation

Ocsidian is ETAPX's agentic game creation platform, built around a simple stubborn belief: from idea to a playable world, with speed, taste, and full creative control. Every architectural decision flows from that sentence, and the AI is one layer in a vertically integrated stack rather than a bolt-on feature. Understanding the stack is the fastest way to understand why agentic tools work here and don't elsewhere.

At the foundation sits the BlackFrost Engine, the proprietary runtime and editor core. It carries everything a real game needs: a full 3D scene graph with PBR materials, environment lighting, shadows, and a deep post-processing stack (screen-space reflections, ambient occlusion, temporal anti-aliasing, motion blur, volumetric light scattering). It runs Havok physics natively — rigid bodies, collisions, and constraints — both in the editor and in exported projects, so what you build is what ships. It generates navmeshes with Recast for AI pathfinding. And it exposes visual node editors for materials, particles, geometry, render graphs, and flow graphs. This matters for AI because the engine is structured, inspectable, and addressable. An agent can reason about a render graph because a render graph is a graph, not a wall of opaque settings.

On top of the engine sits Ocsidian Os, the native desktop editor that ships as a standalone macOS and Windows app. This is where a creator actually lives — the home screen, project creation, the inspector, and the feature that makes agentic work honest: one-click live preview. Press play and the editor launches a local dev server and opens your project for real-time testing. The agent and the human share the same loop. Make a change, run it, see it, judge it, change it again.

The third piece is the scripting system, which is TypeScript-first with decorators, hot reload, and editor-aware metadata for visual property binding. This is a deliberate and slightly contrarian choice, and it's one of the most important reasons agentic creation works well in Ocsidian.

Why TypeScript-First Scripting Is an AI Decision as Much as a Developer Decision

When you choose a scripting language for a game engine, you're usually optimizing for performance or for how comfortable it feels to your existing users. We had a third constraint that most engines didn't have when they made this choice years ago: the language also has to be legible to an agent and verifiable by a compiler.

TypeScript is extraordinary on that axis. It's the most widely written, most thoroughly documented, most heavily represented language in the world of code that AI systems learn from. Its type system turns a whole category of agent mistakes into compile-time errors you catch before you ever press play. Decorators let a script declare its editor-facing properties declaratively, so an agent can wire a value into the inspector without guessing at glue code. Hot reload means an agent's change shows up in the running scene in seconds, not after a cold rebuild. None of this was an accident. A TypeScript-first engine is, among other things, an engine designed to be a good collaborator for an agent — while still being a completely ordinary, comfortable place for a human to write code by hand.

"We didn't add AI to a game engine. We built an engine whose every layer — scene graph, physics, scripting, preview — happens to be exactly what a capable agent needs to do real work. The AI feels native because the substrate was designed to be legible."

— ETAPX Engineering

From Idea to Playable World: The Loop in Practice

Theory is cheap. Here's the loop an agentic tool actually runs, mapped onto the steps a creator goes through in Ocsidian. The point of laying it out is to show that the agent is not a magic box — it's a fast, tireless collaborator working the same loop a human works, just with the boring parts compressed.

1. Scaffold: A project starts from a template — Ocsidian ships official starters for Next.js, Electron, Vanilla TypeScript, Solid.js, and Nuxt.js, each pre-wired with the engine packages, the Havok physics binary, and editor tooling. The old version of this step was an afternoon of dependency hell. The agentic version is a choice and a project name.
2. Compose: You describe the scene you want. The agent translates intent into scene-graph operations — placing meshes, setting up lights, assigning materials, dropping in a camera. You're editing the result, not authoring every transform by hand.
3. Script behavior: Movement, interaction, game rules. The agent writes TypeScript against the engine's scripting API, the type system catches the obvious mistakes, and hot reload puts the behavior in front of you almost immediately.
4. Wire systems: Physics bodies, colliders, constraints, navmesh generation, particle effects. These are the steps that historically ate hours and broke silently. They're exactly the steps agents are best at, because they're structured, repetitive, and verifiable.
5. Preview and judge: One click launches the live preview. This is the human's moment. You play it. Does it feel right? Is the jump floaty in a good way or a bad way? No agent can answer that. You can.
6. Iterate: You give feedback in the same plain language you started with — "the rain's too heavy, cut it in half and make the lightning rarer" — and the loop runs again.

Read that list again and notice where the human is. The human owns step two's intent, all of step five, and the direction of step six. The agent owns the translation, the wiring, and the tedium. That division isn't a limitation of today's models that will erode over time. We think it's the correct, durable shape of the collaboration. More on why below.

What Actually Gets Democratized

"Democratize" is one of the most abused words in technology, usually meaning "we made a cheaper version." Here it means something concrete and measurable: agentic tools remove specific gates that have kept people out of game creation for decades. Let's be precise about which gates.

• The setup gate: The first and most brutal filter in game dev has always been getting a project to run at all — toolchains, SDK versions, native build steps, physics binaries that don't match your OS. Template scaffolding with self-healing project repair (Ocsidian automatically patches import paths, engine package links, and physics WASM binaries) means a beginner's first hour is spent building, not fighting their environment.
• The boilerplate gate: Implementing a character controller, a camera rig, a save system, an inventory — these are solved problems that every newcomer re-solves painfully. Agents write the well-trodden parts instantly, which means a creator's limited energy goes toward the parts that are actually theirs.
• The vocabulary gate: You used to need to know that "make it shiny and wet-looking" translates to a metallic-roughness material with specific values, or that "smooth camera follow" means a damped interpolation. Agentic tools let you speak in outcomes and translate to engine concepts on your behalf — and, done well, they teach you the vocabulary as they go.
• The iteration-cost gate: When every experiment costs an hour, you run few experiments, which means you learn slowly and play it safe. When an experiment costs a sentence and a few seconds of preview, you try the weird idea. Lowering the cost of being wrong is, quietly, the most creatively liberating thing agentic tools do.

Notice what's not on that list. The agent doesn't democratize having a good idea. It doesn't democratize knowing whether a level is fun. It doesn't democratize the years of accumulated judgment that tell a designer the jump should arc just so. It lowers the walls around the medium; it does not hand out the talent. That's the right outcome, and it's worth saying plainly because the alternative framing — "anyone can make a great game now" — is both false and faintly insulting to the people who've spent their lives learning the craft.

The New On-Ramp: Solo Creators and Small Studios

Ocsidian is built for solo creators, small studios, and teams who want to build without surrendering creative ownership, and the agentic layer changes the math for exactly these people. A solo creator has historically had to be a generalist across an absurd range — 3D, shaders, physics tuning, gameplay scripting, audio, UI, build engineering — and was bottlenecked by whichever discipline they were weakest in. A small studio spent a disproportionate share of its tiny budget on plumbing instead of vision.

Agentic tools rebalance that. The weakest discipline stops being a hard ceiling, because the agent can carry a competent baseline across all of them. The creator's job shifts from "do everything adequately" to "direct everything with taste." That's a genuinely different and, we'd argue, better job — and it's the one most people who got into games actually wanted in the first place.

What Still Requires Human Taste and Craft

This is the section the hype skips, and it's the one we care about most. If you only take one idea from this article, take this: agentic tools make the mechanical parts cheap, which makes the human parts more valuable, not less. When everyone can generate a competent level in an afternoon, the thing that distinguishes a great game from a forgettable one is entirely the stuff machines can't do.

• Feel: "Game feel" — the texture of control, the weight of a jump, the satisfying crunch of an impact — is a thousand micro-decisions that have no correct answer, only a felt one. You tune it by playing it over and over until it's right in your hands. An agent can implement a jump; it cannot know whether this jump feels good to this game.
• Pacing and tension: When to give the player a breath, when to overwhelm them, when to withhold a reward to make it land harder later. This is authored emotion over time, and it requires a model of what it's like to be a person playing — something agents don't have.
• Coherence and voice: A great game feels like it came from someone. The art, the sound, the rules, and the tone all rhyme because one sensibility shaped them. Agents are exceptional at producing competent components and have no native instinct for whether those components belong to the same world.
• Knowing what to cut: The hardest creative skill is subtraction — recognizing that the clever mechanic you spent two weeks on is making the game worse and deleting it. Agents are generative by nature. Editing, in the deep sense, is a profoundly human act of judgment.
• The premise itself: Why should this game exist? What is it actually about? No model originates the spark that makes a creator say "I have to build this." That comes from a human life, and it's the one input the whole pipeline is ultimately in service of.

This is why Ocsidian's brand voice insists on speaking to creators as peers, not as customers, and why the platform's whole reason for being is to preserve creative control rather than replace the creator. An agent that took over the taste layer wouldn't be a better tool — it would be a worse product making worse games. We're not interested in that, and we don't think you are either.

"The future of game creation isn't fewer artists. It's artists who spend ninety percent of their time on the ten percent that only they can do — and let the agent handle the rest."

— ETAPX Product Team

The Old Way vs. the Agentic Way

To make the shift concrete, it helps to put the two workflows side by side. None of this is hypothetical — it's the difference between how a small team shipped two years ago and how the same team works inside an agentic editor today.

Starting a Project

The old way: Install the engine, pick a language runtime, resolve version conflicts, find and link a physics library, configure a build system, and pray the sample scene runs. A motivated beginner could lose a weekend here and quit before building anything.

The agentic way: Choose a template, name the project, and you're in a running scene with physics and tooling already wired. The self-healing repair logic quietly fixes the things that used to be fatal. Time-to-first-play drops from days to minutes.

Building a Mechanic

The old way: Read the scripting docs, write the controller, hook it to input, attach a collider, debug why the character clips through the floor, rebuild, test, repeat. Hours per mechanic, most of it spent on the parts that aren't the mechanic.

The agentic way: Describe the mechanic, let the agent draft the script against the typed API, watch it appear in the live preview via hot reload, then spend your time on the only thing that matters — tuning how it feels.

Polishing the Look

The old way: Manually dial in materials, lighting, and a post-processing stack you half understand, toggling SSAO and TAA and motion blur one at a time to see what each does.

The agentic way: Describe a mood. The agent composes a coherent starting point across materials, lights, and post-processing, and you adjust from a strong first draft instead of a blank scene. The blank scene — the most paralyzing thing in any creative tool — largely goes away.

Use Cases: Where Agentic Creation Shines Today

It's easy to talk in abstractions, so here are the kinds of work where agentic game creation already earns its keep, ordered roughly from most to least obvious.

• Prototyping at the speed of conversation: The single highest-value use. Ideas are cheap; testing them used to be expensive. When you can stand up a playable prototype in an afternoon, you test ten ideas instead of betting everything on one. This is transformative for finding the fun before you've sunk months into the wrong direction.
• Learning by building: A newcomer who can ask the agent "why did you do it that way?" and read the resulting typed, commented script learns faster than one grinding through documentation in isolation. The agent becomes a patient senior developer pairing with you on your own project.
• Interactive experiences beyond games: Not everything built in a game engine is a game. Product configurators, architectural walkthroughs, training simulations, interactive art, branded experiences — agentic tools open 3D interactivity to people who were never going to learn a full engine but have a clear thing they want to build.
• Carrying the weak discipline: A brilliant level designer who can't write shaders, or a sharp programmer with no eye for lighting, can lean on the agent for the half of the craft they don't have, and stay in flow on the half they do.
• The unglamorous maintenance work: Refactoring a scene's structure, regenerating navmeshes after a layout change, migrating assets, fixing import paths across a project. Pure tedium, perfectly suited to an agent, and a real quality-of-life win on any project that lives longer than a weekend.

The Edge Cases and Honest Limits

We'd be doing exactly the hype we claim to dislike if we pretended this is frictionless. Here's where agentic creation gets hard, and where a careful human stays firmly in the loop.

• Deep systemic design: A sprawling, interlocking systems game — where the economy, the combat, and the progression all feed each other — is more than the sum of generated parts. The connective tissue is design, and design is the human's job. The agent helps build the systems; it cannot architect their interplay.
• Runtime behavior the compiler can't see: TypeScript catches a lot, but the gnarliest game bugs are emergent — a physics constraint and an animation fighting over a transform, a state machine that deadlocks only under a specific input sequence. These need a human who can reproduce, reason about, and form a hypothesis. The live preview is the indispensable tool here precisely because some truths only appear at runtime.
• Performance under real load: An agent can write correct code that's also too slow. Frame-budget discipline — knowing that this elegant approach will tank the framerate on a mid-range machine — is hard-won engineering judgment that you supply.
• Taste collisions: Sometimes the agent's competent, reasonable default is exactly wrong for your specific vision, and you have to recognize that and overrule it. The danger isn't the agent being wrong; it's the agent being plausibly, seductively almost-right, and you accepting it because it's easier than insisting on what you actually wanted.

The Quiet Risk: Drifting Toward the Average

That last point deserves its own warning, because it's the subtlest risk in the whole shift. Agents are trained on what exists. Left unchecked, they nudge everything toward the median of what's already been made — the competent, the conventional, the seen-it-before. If you accept defaults uncritically, you don't get a bad game. You get an average one, which in a crowded medium is arguably worse, because nobody remembers average.

The antidote is the same as it's always been: a creator with a strong point of view who uses the agent to execute a vision rather than to supply one. The tool is most dangerous to people who don't know what they want, and most powerful in the hands of people who do. That's not a flaw to be patched. It's the nature of any powerful instrument.

The Risks We Take Seriously

Beyond craft, there are real responsibilities that come with putting this much capability in this many hands. We won't pretend they're solved, but we'll say where we stand.

• Ownership and authorship: Creators should own what they make, full stop. Ocsidian's entire premise is creative control, and that has to extend to clarity about what's yours. The agent is a tool you direct; the work is the creator's.
• The deskilling fear: There's a legitimate worry that if agents do the fundamentals, newcomers never learn them. We take the opposite design stance — the agent's output should be legible and inspectable (typed, structured, readable scripts you can open and understand), so it teaches rather than hides. A black box deskills; a glass box educates.
• A flood of low-effort content: Lower barriers mean more output, and not all of it good. We think that's fine and historically normal — every democratized medium goes through it, from desktop publishing to digital music to video. The cream still rises, and the floor rising means more people get to find out whether they have something to say.
• Over-reliance and fragility: A creator who can only build with the agent and can't reason about their own project is in a fragile position. Good tools should build understanding, not dependence — which, again, is why legibility over magic is a principle and not a slogan for us.

How This Connects to the Wider ETAPX Ecosystem

Ocsidian doesn't exist in isolation, and the way it sits inside ETAPX is part of why we think our point of view here is more than theory. ETAPX is the parent technology company building three products in one connected ecosystem, all sharing a single account and a single philosophy: user-first, built in-house, craft-driven.

• Ocsidian is the agentic game creation platform — the subject of this piece, and our deepest bet that AI's role in creative work is to amplify human taste rather than replace it.
• GLSRM is the front page of AI at glsrm.com — a live intelligence surface tracking the field as it moves: news, models, releases, research, agents, benchmarks, and Elo standings across hundreds of models and dozens of labs. It's how we, and anyone building with AI, stay honest about what's actually state of the art versus what's marketing.
• Whistlr is the social platform — the place where creators share, discuss, and find each other. GLSRM's community layer, Circuits, already threads into the Whistlr ecosystem, so one account connects a person across the whole thing.

The connection isn't a marketing convenience; it's a feedback loop. GLSRM keeps us — and our creators — grounded in the real, fast-moving frontier of AI capability rather than a frozen snapshot of what models could do last year. Ocsidian turns that capability into actual creative power inside a real engine. Whistlr gives the work somewhere to live and an audience to find. Build, understand, share — across one account, by one company that builds its own tools end to end rather than stitching together other people's.

"We track the whole AI field on GLSRM precisely so we never build on hype. What we ship in Ocsidian is grounded in what these systems can genuinely do today — and we're honest with creators about the line between the two."

— ETAPX Engineering

Why We Built It This Way

It would have been faster and cheaper to wrap an existing engine, slap a chat box on the side, and call it agentic game creation. A lot of products do exactly that. We chose the harder path — a vertically integrated platform with our own engine, our own desktop editor, and our own runtime — for reasons that are worth stating plainly, because they explain the quality difference.

When you control the whole stack, the agent can reach all the way down. It can reason about the scene graph because we designed the scene graph. It can write scripts that compile because the scripting system, the type definitions, and the editor metadata are ours and consistent. It can run the result because the live preview is a first-class part of the editor, not a third-party afterthought. An agent stitched onto a closed engine is always working through a keyhole. An agent native to an integrated platform works in the open.

The same goes for craft. A wrapper inherits someone else's defaults, someone else's rough edges, someone else's idea of what good looks like. Building in-house — which is an ETAPX principle across every product, not just this one — means the taste is ours to set and ours to defend. That's the only way to make a tool that genuinely respects the creator's taste: by having strong taste yourself, baked into every layer the creator touches.

Frequently Asked Questions

Will agentic AI tools replace game developers?

No, and the framing misunderstands the work. Agentic tools replace the tedious, repetitive parts of game development — the setup, the boilerplate, the wiring, the maintenance — not the creative parts. Game feel, pacing, coherence, knowing what to cut, and the original premise of a game all remain firmly human. If anything, by making the mechanical work cheap, these tools raise the value of the human judgment that no model can supply. Developers spend more of their time on the work that actually requires them.

Do I need to know how to code to use Ocsidian?

You can get a long way describing what you want in plain language and letting the agent translate it into engine operations and TypeScript. But Ocsidian deliberately makes the generated work legible — readable, typed, structured scripts you can open, understand, and edit by hand. So you don't need to code to start, and the tool helps you learn to code as you go if you want to. Coders, meanwhile, get a completely ordinary, powerful TypeScript scripting environment with hot reload and editor-aware property binding.

What is the difference between an AI assistant and an agentic tool?

An AI assistant is reactive — it completes the line you're typing and operates one step ahead of you. An agentic tool operates on intent: you describe an outcome, and it plans a sequence of actions, executes them, inspects the result, and iterates. The difference is between something that shortens the act of typing and something that shortens the act of building. Agentic tools carry out multi-step creative work alongside you rather than just suggesting the next token.

Why does Ocsidian use TypeScript for scripting?

Three reasons that reinforce each other. First, it's familiar and comfortable for the millions of developers who already know it. Second, its type system turns a whole category of mistakes — including agent mistakes — into compile-time errors you catch before running anything. Third, it's deeply represented in what AI systems have learned from, which makes it an excellent language for an agent to write well. A TypeScript-first engine is, by design, both a great place for humans to write code and a great collaborator for an agent.

Can agentic tools actually understand a 3D scene, or do they just generate text?

The useful ones understand the scene. In Ocsidian, the agent works against a structured, inspectable engine — a scene graph, materials, lights, physics bodies, particle systems, and node-based editors that are all addressable. It can reason about these because they're real, organized objects, not opaque settings. Crucially, it can also run the project in the live preview and observe the result, which is what separates a tool that builds working games from one that produces plausible-looking text that doesn't run.

What kinds of things can I build besides games?

Anything that benefits from real-time 3D interactivity. Product configurators, architectural and real-estate walkthroughs, training and safety simulations, interactive art and installations, branded marketing experiences, and educational tools are all natural fits. Because Ocsidian ships with project templates for Next.js, Electron, Vanilla TypeScript, Solid.js, and Nuxt.js, interactive experiences can be embedded into web and desktop products, not just shipped as standalone games.

How does Ocsidian fit into the rest of ETAPX?

Ocsidian is one of three connected products under ETAPX, all sharing a single account and a user-first, craft-driven philosophy. GLSRM, the front page of AI, keeps the whole ecosystem grounded in the real, current state of AI capability across hundreds of models and dozens of labs. Whistlr, the social platform, is where creators share their work and find each other. Ocsidian turns AI capability into creative power inside a real engine. Build, understand, share — across one connected account.

What's the biggest mistake people make with agentic creation?

Accepting the defaults uncritically. Agents are trained on what already exists, so left unchecked they pull everything toward the average of what's been made before. The result isn't a bad game — it's a forgettable one, which in a crowded medium is worse. The fix is to come in with a strong point of view and use the agent to execute your vision rather than to supply it. These tools are most powerful in the hands of people who know exactly what they want.

Where This Is Heading

Step back from the day-to-day and a clear direction emerges. The cost of turning an idea into a playable, interactive experience is collapsing, and it isn't going to stop. The question that defines the next several years is not "can AI make games?" — it can already help make them — but "what happens to a medium when the price of entry falls to nearly zero?"

History gives us a confident answer. When desktop publishing put a print shop on every desk, we didn't run out of great writing — we got more of it, from more people, and the gatekeepers lost their monopoly on who got to be heard. When digital tools democratized music and film, the same thing happened. There was a flood, and there was also a renaissance, and the renaissance is the part we remember. Game creation is about to have its version of that moment, and agentic tools are the lever.

What we expect, concretely: a generation of creators who never would have made it past the setup gate will make their first game. Small studios will punch far above their headcount because the agent carries the plumbing for a team of three. Prototyping will get so cheap that the industry stops betting years on unvalidated ideas and starts finding the fun first. And — this is the part we're most certain of — the value of genuine taste, originality, and a real point of view will go up, not down, because when everyone can build the average, the only thing worth anything is the work that isn't average.

That's the future ETAPX is building toward, and it's why we built Ocsidian the way we did: an agentic platform that compresses the tedium to nearly nothing while guarding the creative control that makes a game worth playing. We're not trying to take the human out of the loop. We're trying to give the human back the parts of the loop they actually love — and let the machine handle the rest. The tools are finally good enough to make that a real promise instead of a pitch. What gets built next is up to the creators. We just want to make sure the only thing standing between them and a playable world is their own imagination.