blog/posts/agentic-workflow.md

title, slug, date, description, og_description, og_image, excerpt, author, author_initials, author_role

title	slug	date	description	og_description	og_image	excerpt	author	author_initials	author_role
How a 4-Person Studio Runs on AI Agents	agentic-workflow	2026-03-06	We gave AI agents persistent identities, skill playbooks, and access to our entire knowledge base. Here's how four people ship like forty.	Soul files, skill playbooks, and markdown as the universal API for AI agents in game dev.	https://www.tinqs.com/blog/img/agentic-workflow-architecture.png	We gave AI agents persistent identities, skill playbooks, and access to our entire knowledge base. Here's how four people ship like forty.	Ozan Bozkurt	OB	CTO & Developer, Tinqs

Last week one of our agents caught a stale bug at 3am — a vegetation culling issue that had been open for six days. It nudged the team chat, drafted a fix summary, and by morning the issue was resolved. Nobody lost sleep. Nobody context-switched. The agent just handled it.

This is what happens when you stop treating AI as a chatbot and start treating it as a team member with a persistent identity, a memory, and a set of skills it can actually execute.

The problem with "just use ChatGPT"

Every small studio hits the same wall: four people, forty roles. Nobody has time to keep documentation current. Bugs pile up. The backlog rots. Someone asks "what did we decide about the inventory system?" and three different answers come back.

The usual fix is more tools — Notion, Trello, Linear, Slack integrations. But tools are passive. They sit there waiting for humans to update them. In a team where the lead developer is also the CTO, that human is already stretched thin.

We tried something different. Instead of adding more tools for humans to maintain, we gave AI agents persistent identities, connected them to our entire knowledge base, and let them do the maintenance.

Soul files: giving agents a personality that sticks

The core idea is embarrassingly simple. Every agent gets a soul file — a markdown document that defines who it is, what it values, and how it should behave:

• Values — "never break the build," "always verify before acting," "prefer existing patterns over novelty"
• Knowledge scope — what repos exist, who's on the team, what the game is about
• Behavioural rules — when to act autonomously, when to ask, what requires explicit human approval

This isn't theatre. It's the difference between an agent that asks "what project is this?" every session and one that says "I see the vegetation grid was updated yesterday — want me to check the cache eviction?"

The soul file loads in 100ms when the agent starts. No cold starts. No re-explaining.

Memory: markdown in git, not a vector database

Agent memory lives as plain markdown files in our docs repo. No vector databases, no proprietary stores, no SaaS dashboards. The agent writes to its memory file during work, commits it, and reads it on the next session.

This is deliberately low-tech. Markdown in git gives you version history, diffs, branching, and human readability for free. When memory goes wrong — and it will — you git log to see what changed and git revert to fix it. Try debugging a corrupted vector embedding at 11pm.

Skills: teachable playbooks, not prompt engineering

Agents don't just have instructions. They have skills — markdown playbooks that teach specific workflows. When someone says "generate concept art for a character," the agent reads skills/image-generation.md and follows the procedure. No prompt engineering per session. No "let me try a different prompt."

We've open-sourced several skills:

• Image Generation with fal.ai — 4-layer prompt pattern that actually produces usable game art
• Concept Art Pipeline — full 2D concept → 3D model workflow
• 3D Model Generation — Tripo Studio text-to-3D
• Video Generation — trailer clips with Sora 2

Each skill took about 30 minutes to write. After six months, our agents have 15+ skills covering art generation, competitive research, video production, and project management. Skills compound — every playbook you write makes every future session more capable.

What the agents actually do, every day

During the day (interactive, inside the IDE):

• Triages and grooms the issue backlog
• Keeps documentation in sync with what's actually in the game
• Processes tester bug reports and creates structured issues
• Generates concept art, trailer frames, UI icons on demand
• Conducts competitive research — Steam pages, player reviews, pricing

The team talks to the agent through voice. The IDE microphone transcribes, and the agent interprets intent from messy voice-to-text. "There's a tree floating two meters above the terrain on the west beach" becomes a filed issue with a screenshot, a vision-model description, and coordinates.

At night (background daemon, $15/day):

• Polls team chat every 15 minutes, responds to commands
• When a tester reports a bug in chat, creates a structured issue automatically
• Flags stale issues that haven't been touched
• Posts a morning digest of what happened overnight
• Creates its own skill files when it discovers better approaches

What we learned

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

Cheap models for routine, expensive models for thinking. Most of what an agent does is pattern matching — "does this look like a bug report?" You don't need DeepSeek Pro for that. Save the premium tokens for decisions that actually require reasoning. Our background daemon costs $15/day with a three-tier model strategy.

Voice changes everything. When you can describe a bug while looking at the screen, and the agent transcribes, interprets, and files it — that collapses the distance between noticing a problem and tracking it. Keyboard-free bug reporting is a superpower.

Skills compound exponentially. One skill saves 15 minutes per session. Fifteen skills save hours per day across the whole team. The investment curve is absurdly favourable — 30 minutes of writing per skill, compounding returns forever.

We're four people. With agents doing the mechanical work, we operate like forty. Not because the AI is magic — because we gave it identity, memory, and the right playbooks, and then got out of its way.

---

We're building Ariki, a survival colony sim, using the same agent workflow described here. Everything runs on Tinqs Studio — a game dev platform with built-in AI agents, git hosting, and creative pipelines.