How a Small Game Studio Runs on AI Agents

The Problem Every Small Studio Knows

When you're four people building a game, there's no room for a dedicated DevOps person, a full-time PM tool chain, or someone whose job it is to "keep things organised." Everyone wears five hats. Documentation drifts. Issues pile up. The left hand doesn't know what the right hand shipped.

We tried the usual tools — Notion, Trello, shared Google Docs. They all had the same problem: they're passive. They sit there and wait for a human to update them. In a team of four where the lead developer is also the CTO, that human never has time.

So we built something different. We gave AI agents persistent identities, connected them to our entire knowledge base, and let them become working members of the team.

The Architecture: Agents with Identity

Our primary AI agent runs inside the IDE and has access to the full documentation repository — the game design document, backlog, meeting notes, company operations, everything. It's not a chatbot. It's a persistent team member with a soul file that defines its values and operating principles, and a memory file that persists context across sessions.

The key insight: all knowledge lives in markdown files in one repo. No databases, no SaaS dashboards, no proprietary formats. Plain text, version-controlled, readable by humans and agents alike. When anyone on the team opens the docs repo, the agent wakes up with full context of who they are, what machine they're on, and what's been happening.

What the agent actually does

• Triages and grooms the issue backlog
• Keeps documentation in sync with the game state
• Processes bug reports from testers and creates structured issues
• Drafts team announcements, reviews PRs, manages cross-repo coordination
• Generates concept art, trailer frames, and UI assets using integrated API skills
• Conducts competitive research — analysing Steam pages, player reviews, pricing strategies

The team talks to the agent through voice. The IDE's built-in microphone transcribes and auto-translates (multilingual team). The agent is trained to interpret messy voice-to-text artifacts and act on intent, not grammar.

Background Automation

The interactive agent only runs when someone opens the IDE. But a studio doesn't sleep — bugs get reported at midnight, issues go stale, and the team chat fills up while everyone's away.

A background daemon runs 24/7, ticking every 15 minutes. It uses a three-tier model strategy — cheap models for routine checks, medium for analysis, and premium only when it needs deep reasoning. The whole thing costs about $15/day.

What it handles

• Chat monitoring — polls team chat, responds to commands, acknowledges messages
• Bug intake — when a tester reports a bug in chat, creates a structured issue automatically
• Stale issue detection — flags issues that haven't been touched, nudges the team
• Daily summaries — posts a morning digest of what happened overnight
• Self-learning — creates its own skill files when it discovers better approaches

The two agents coordinate through the docs repo itself. One writes, the other reads. No API calls between them, no message queue. Just git.

The Skill System

Agents don't just have instructions — they have skills. Each skill is a markdown file that teaches the agent a specific workflow: how to generate concept art through a pipeline, how to use image generation APIs, how to conduct competitive research, how to create 3D models from concept art.

When someone asks the agent to do something that matches a skill, it reads the skill file and follows the procedure. This means you can teach the agent new capabilities without changing any code — just write a new markdown file.

We've open-sourced several of our skills in this repo:

• Image Generation with fal.ai
• Concept Art Pipeline
• 3D Model Generation with Tripo
• Video Generation with Sora 2

Soul Files: Why Identity Matters

Giving the agent a persistent identity isn't theatre. It creates consistency across sessions. The soul file defines:

• Values — what the agent prioritises (e.g., "never break the build," "always verify before acting")
• Knowledge scope — what repos, services, and team members exist
• Behavioural rules — how to handle ambiguity, when to ask vs act, what requires human approval

The agent remembers what it learned, adapts to who's asking, and maintains the same principles whether it's triaging bugs or drafting a Steam page description. The soul file is the agent's constitution.

What We've Learned

Plain text is the universal API. Every tool, every agent, every human can read a markdown file. We store everything — design documents, meeting notes, agent memory, team contacts — as .md files in one repository. This sounds almost too simple, but it eliminates an entire class of integration problems.

Cheap models for routine, expensive models for thinking. Most of what an autonomous agent does is pattern matching and text formatting — you don't need the most expensive model for that. Save the premium tokens for decisions that actually require reasoning.

The human stays in the loop for decisions. The agents can file issues, draft announcements, and generate assets — but they don't merge code, deploy builds, or post to public channels without explicit approval. The workflow is designed so the AI handles the grunt work while humans make the calls that matter.

Voice input changes everything. When you can describe a bug while looking at the game screen, and the agent transcribes, interprets, and files an issue — that's a workflow that collapses the distance between noticing a problem and tracking it.

Skills compound. Every skill file you write makes the agent more capable. After 6 months, our agents have 15+ skills covering art generation, competitive research, video production, and project management. Each one took 30 minutes to write and saves hours every week.

The Numbers

• Team size: 4 humans + AI agents
• Background agent cost: ~$15/day (~$450/month)
• Knowledge files: 200+ markdown documents
• Skills: 15+ agent skill files and growing
• Infrastructure: Multiple machines, self-hosted git, zero DevOps engineers

We're not claiming this is how every studio should work. But for a small team trying to build something ambitious, having AI agents that actually understand the project — not just answer questions about it — has been transformative. The agents don't replace anyone on the team. They make it possible for four people to do the work of forty.

We're building all of this as part of Tinqs Studio — a game development platform that brings git hosting, AI tools, and team workflows together. The blog posts and skills in this repo are part of that journey.