For years, technical art teams have automated the parts of game production that can be easily described in deterministic terms.
File validation, asset importing, build preparation, naming conventions, and repetitive configuration work can all be handled with scripts when the rules are clearly defined.
At the same time, tasks that are difficult to formalize and reduce to an unambiguous set of rules have traditionally remained in human hands.
Understanding what exactly is shown in an image. Comparing an art request with a game design document. Determining where an asset should go. Examining the structure of a scene and spotting something unusual. Making large-scale coordinated changes without breaking dependencies.
At Age of Magic, Playkot’s fantasy RPG, AI is beginning to push automation into precisely this area. “We have always built tools,” says Aleksander, Lead Tech Artist at the Age of Magic studio (Playkot). “Anything that could be measured numerically or analyzed algorithmically could already be automated in the traditional way. What changed with agentic workflows is that we can now delegate tasks that used to be considered exclusively human work.”
This transition did not happen as a result of a single company-wide AI initiative. The Tech Art team had been following new tools for a long time and periodically testing whether the technology had matured enough to solve real production problems.
Once commercial-grade agentic systems became stable enough, Alexander saw an opportunity to rethink workflows that had previously resisted traditional automation.
The Most Expensive Work Was Not Always the Most Complex
One of the first conclusions was that the biggest productivity gains do not necessarily come from automating the most intellectually demanding tasks.
Age of Magic is a game heavily built around LiveOps. Every release brings a significant amount of 2D content: offer art, icons, currencies, event assets, and other supporting visual materials.
Alexander estimates that a single release can contain around 200 images.
Uploading those images itself was not particularly difficult. The expensive part of the process was understanding what each asset represented, comparing it with the game design documentation, checking naming and IDs, determining where it should go, preparing testing tables, and making sure the content matched the intended feature. This analytical preparation could take six to eight times longer than the mechanical upload itself.
Today, a significant part of this layer has been delegated to an agent.
The more intellectually demanding work – designing new visual systems, decomposing new features, and making architectural decisions – remains under direct human control. AI can help write code or execute a task, but the Tech Artist still defines the structure and reviews the result.
This distinction has become an important principle for the team: automate repetition, not authorship.
Teaching AI a Programming Language It Has Never Seen
The second major use case emerged from one of Age of Magic’s unusual technical constraints. The game itself runs on Unity and C#, but part of its gameplay logic is written in a proprietary programming language.
This language became a bottleneck.
Its documentation was incomplete, the underlying virtual machine was complex, and deep expertise was concentrated in just one or two people. Whenever a developer needed to introduce a fundamentally new mechanic or extend the language, the task could become either a serious schedule risk or a complete blocker. Sometimes game design decisions were constrained not by the quality of the idea, but by the availability of the few people who understood the system deeply enough to implement it.
A standard LLM could not simply solve this problem “out of the box.” The language was internal, so the model had no meaningful prior knowledge of it. The team considered more specialized approaches, including fine-tuning, but ultimately chose a different strategy.
Alexander asked a simple question: if we hired a new engineer, how would we teach them this system? The answer was documentation.
The team generated documentation for the codebase at multiple levels of abstraction, verified it with domain experts, and turned it into a hierarchical knowledge structure that the model could use as context.
Instead of teaching the model the language through a custom training pipeline, they taught it how to navigate the system in the same way a new developer would.
Today, the result is stable enough that, according to Alexander’s estimate, AI can generate roughly 90% of a character’s gameplay logic before the manual refinement stage.
The impact is measurable. Previously, the gameplay logic for a single character required roughly 24–36 hours of work, depending on complexity. Today, the same stage takes around 6–10 hours. The bug-fixing process has changed as well. Work that could previously add another 30 hours can now often be completed in roughly eight. The benefit is not only speed.
It also increases the number of developers who can work with the proprietary system without first having to spend months learning all of its internal layers.
Smaller Context Produces Better AI Results
Building the documentation was only part of the challenge.
The team also learned that giving the model more information is not always the right approach. In fact, one of the most important principles behind the pipeline is to keep the active context as narrow as possible. The documentation is structured hierarchically rather than stored in one giant Markdown file. A top-level document describes the systems and links to more specific documents, which in turn lead to even narrower subsystems.
The agent starts at the top level and follows only the branch relevant to the current task. “The goal for stable generation is essentially the smallest possible context window,” Alexander says.
The same principle applies to the work itself. Instead of generating an entire character at once, the team works with each ability separately. A typical hero may have four or five abilities, and each one is handled as a separate unit.
When Alexander experimented with generating entire characters in a single pass, hallucinations increased. Breaking the work into smaller independent blocks produced much more stable results.
The team also separates reasoning from deterministic operations.
If an agent needs to update a configuration file across several abilities, it does not necessarily edit the data directly. Instead, deterministic Python scripts act as small APIs: the agent decides what should happen and calls a trusted script that performs the actual change. The result is a hybrid architecture: LLM for interpretation and decision-making; deterministic code for operations where there should be no ambiguity.
From 200 Images to a Ready Merge Request
The 2D-content pipeline takes the same philosophy much further.
Before automation, a Tech Artist would open several art tasks, download around 200 images, sort them, read the game-design document, determine what each image represented, match IDs and technical requirements, prepare tables and manually identify anything that was missing or incorrect. The analysis alone could take four to six hours. Today, the workflow can run almost entirely in the background.
The agent receives a task containing links to the source assets and the relevant game-design documentation. Through internal integrations, it can read the design document, retrieve assets from Google Drive, analyse naming, resolution and visual content, determine what type of asset each image represents and connect it to the appropriate part of the feature.
It then places the assets into the correct project hierarchy, prepares import metadata, resolves the required internal references and creates a merge request. The system can also post a status message and identify problematic content: missing assets, incorrect IDs, wrong image sizes, incorrect slices or other discrepancies that previously had to be found by eye. If everything is correct, the Tech Artist may only need to switch to the relevant branch, inspect the result and approve the merge. If something is wrong, the agent has already prepared a list of areas that need to be checked.
The four-to-six-hour analytical stage effectively disappears from the specialist’s active workload because it runs in the background while the person works on something else.
Importantly, not every part of the pipeline is generated by AI.
For example, Unity metadata is created using deterministic Python code rather than an LLM. The agent orchestrates the process, but predictable technical operations remain predictable.
The Human Still Remains the Final Validator
Autonomy does not mean that the agent has the final say.
The final validator is still a person.
The system checks whether all assets requested by game design exist, whether they have the correct format and resolution, whether IDs match the intended content and whether references are valid. But before the content moves further through the production pipeline, a Tech Artist still reviews the result and takes responsibility for approving it. For Alexander, this is less about distrust of AI and more about ownership. He does not want to delegate the decomposition of new visual features or the architecture of new systems.
“AI is a very good executor,” he says. “Our responsibility as the people working with it is to understand exactly what it is doing and to remain responsible for the outcome.”
There is also a less obvious technical risk. AI can generate technical debt much faster than a human can. “If we lose control over what AI generates, there is a huge risk of creating legacy at a speed that humans simply could not create it themselves,” Alexander says. That is why the team delegates only tasks it understands well enough to verify. The goal is not to reduce Tech Art capacity.
The goal is to redirect that capacity toward research, new systems, architecture and identifying new bottlenecks.
Less Digital Paperwork, More Real Interaction
One effect of the new workflows turned out to be unexpectedly human.
Tech Art has always been a cross-functional discipline. Technical artists sit at the intersection of game design, art and engineering and spend a significant amount of time helping those parts of production work together. AI has not reduced the amount of that interaction. According to Alexander, it has increased its density.
A large share of the digital equivalent of “moving papers around” has disappeared: copying data, sorting files, checking repetitive structures and performing routine handoffs between stages. When these tasks stop consuming attention, Tech Artists can spend more time discussing quality, requirements and trade-offs with artists, developers and game designers.
This is another pattern visible in AI adoption in game production: the technology often removes communication overhead without removing communication itself.
The Next Step: Internal AI Products
Age of Magic is now moving beyond individual pipelines.
The team has begun working on standalone internal tools – small products created for employees rather than players.
Before AI, many such ideas simply lost the prioritisation battle.
If a useful internal search tool required six months of development, the obvious alternative was to spend those same six months shipping game features. Now that development productivity has increased, such tools are becoming economically realistic. Alexander sees them as “small productions inside production”: they have users, goals and a product experience of their own, but the performance requirements are often less demanding than those of player-facing game systems.
One example is semantic asset search.
Instead of relying on someone remembering that a particular image was created years ago and knowing where it lives in a terabyte-scale archive, an artist could describe what they are looking for and let the system find visually relevant content.
This could prevent the team from recreating an asset that already exists and save additional art production time.
At this stage, AI stops being simply an agent that performs work.
It becomes a component of a new generation of internal software.
A Tech Artist With a Team of Agents
Alexander expects the stable part of LiveOps production to become increasingly autonomous. For repeatable workflows, the endpoint may be a set of agents and deterministic tools that handle everything after an artist finishes the source content – potentially triggered by something as simple as a button in a task-management system.
But he does not think this fully describes the future of Tech Art. New visual features, new projects and new technical systems still require a person who can invent the architecture, define artistic and technical requirements across disciplines, design testing approaches and make trade-offs between teams.
In his view, that part should remain human.
What changes is execution. Once the system has been designed and decomposed into clearly defined tasks, more and more of those tasks can be handed to agents, while the Tech Artist reviews the code, provides corrections and retains authorship of the system itself. Alexander compares the likely future to having a personal team of junior- and mid-level executors – except those executors are agent systems configured by the specialist.
“You still have to formulate the task,” he says. “You still have to define the requirements. But execution can increasingly be delegated.”
That may be the most important change for Tech Art at Age of Magic. AI is not removing the need for technical artists.
It is moving them upward – from integrators and operators toward architects, reviewers and designers of the production systems themselves.
