{{TITLE}}
+{{LEAD}}
+ +
+{{BODY}}
+
+
+
+ Behind-the-scenes notes on building games, forging tools, and running a small studio that punches above its weight.
+{{LEAD}}
+ +An agent harness is the layer between a raw AI model and a useful team member. It gives the agent identity, memory, tools, and guardrails. Tinqs Studio is an agent harness built specifically for game development.
+
+## What Is an Agent Harness?
+
+A raw AI model — Claude, GPT, Gemini — is powerful but stateless. It doesn't know who you are, what project you're working on, what tools are available, or what happened yesterday. Every session is a cold start. Every conversation begins with "let me explain the project..."
+
+An agent harness solves this. It wraps around the model and provides:
+
+- Identity — who the agent is, what it values, how it should behave
+- Memory — what happened in previous sessions, what was decided, what failed
+- Tools — what the agent can actually do beyond generating text
+- Context — what project this is, who's asking, what infrastructure exists
+- Guardrails — what the agent must never do, what requires human approval
+
+Without a harness, you have a chatbot. With one, you have a team member.
+
+## Why Game Dev Needs Its Own Harness
+
+Generic agent harnesses exist — LangChain, CrewAI, AutoGen. They're built for web apps, data pipelines, and customer support. Game development has different problems:
+
+Assets are binary. A web developer's PR is a text diff. A game developer's PR is a 150MB GLB file. Generic harnesses don't know how to preview 3D models, manage LFS bandwidth, or review binary assets.
+
+The pipeline is visual. Game dev goes from concept art to 3D model to rigged character to in-engine asset. Each step uses different tools — image generators, 3D modellers, auto-riggers, game engines. An agent harness for game dev needs to orchestrate this entire chain.
+
+Scale is physical. A web app's complexity is in business logic. A game's complexity is in geometry — 12km worlds, 155 vegetation prototypes, 576 terrain regions, 2000 crowd instances. The agent needs to understand spatial systems, GPU memory, and frame budgets.
+
+The team is small and cross-functional. A 4-person game studio has no dedicated DevOps, no dedicated artist, no dedicated PM. The harness needs to fill all those gaps, not just one.
+
+## How Tinqs Studio Works as a Harness
+
+Tinqs Studio is a platform built on a Gitea fork with game-specific features layered on top. But the git platform is just the foundation. The harness is everything around it.
+
+### Identity: Soul Files
+
+Every agent session starts by loading a soul file — a markdown document that defines the agent's persistent identity. Not just "you are a helpful assistant" but specific values, knowledge scope, and behavioural rules.
+
+The soul file means the agent behaves consistently whether it's triaging bugs at 9am or generating concept art at midnight. It knows what repos exist, who the team members are, what the game is about, and what decisions have been made. Identity isn't cosmetic — it's the difference between an agent that asks "what project is this?" and one that says "I see the vegetation grid was updated yesterday, want me to check the cache eviction?"
+
+### Memory: Markdown Files in Git
+
+Agent memory is plain markdown files in a git repository. No vector databases, no proprietary stores. The agent reads its memory on session start, updates it during work, and commits changes back.
+
+This is deliberately low-tech. Markdown in git gives you version history, branching, merge conflict resolution, and human readability for free. When memory goes wrong — and it will — you can git log to see what changed and git revert to fix it.
+
+### Tools: The CLI
+
+A single Go binary gives every agent access to:
+
+- Identity loading — full project context in 100ms
+- Screenshots — capture any window from outside the process
+- Cloud vision — send screenshots to a vision model, get structured descriptions
+- Health checks — verify services, repos, and tools are working
+- Service status — which URLs are live, what's reachable
+
+The CLI is the agent's hands and eyes. Without it, the agent can only read and write text. With it, the agent can see the game running, photograph bugs, and verify infrastructure.
+
+### Skills: Teachable Workflows
+
+Skills are markdown playbooks that teach agents specific procedures. Instead of hoping the model figures out how to generate concept art or create a 3D model, you write the steps once:
+
+- Image Generation — generate game art with fal.ai Flux using a 4-layer prompt pattern
+- Concept Art Pipeline — from design brief through 2D art to 3D model export
+- 3D Model Generation — Tripo Studio text-to-3D and image-to-3D
+- Video Generation — trailer clips with OpenAI Sora 2
+
+Skills compound. Every playbook you write makes the agent more capable. After six months, our agents handle art generation, competitive research, video production, project management, and code review — all from markdown files.
+
+### Git Platform: 3D Preview and LFS
+
+The Gitea fork underneath handles the game-specific git problems:
+
+- 3D asset preview — rotate GLB/FBX/STL files in the browser during code review
+- LFS-first workflows — auto-tracking for game file extensions, storage dashboards
+- OAuth2 SSO — one login for git, tools, and the game
+- 22 format support — GLB, FBX, OBJ, STL, 3DS, PLY, and more via O3DV
+
+### Guardrails: Human-in-the-Loop
+
+The harness defines what agents can and cannot do:
+
+- Agents can file issues, draft announcements, generate assets, write code
+- Agents cannot merge code, deploy builds, push to public repos, or post to external channels without human approval
+- The public blog repo requires human-approved merge requests — agents can propose changes but a person must review
+
+This isn't a limitation — it's a feature. The agent handles volume; the human handles judgement.
+
+## The Cold Start Problem
+
+The biggest problem with AI agents in production isn't capability — it's context. Every new session is blank. The agent doesn't know what happened yesterday, what's in progress, or what tools are available.
+
+Most teams solve this with long system prompts. That works until your context is 200 markdown files, 15 skills, and 3 years of project history. You can't paste all of that into a system prompt.
+
+The harness solves this with staged loading:
+
+1. CLI identity call (100ms) — loads soul file, company context, machine info, service status
+2. Memory file (instant) — loads cross-session context
+3. Skills (on demand) — loaded only when the task matches a skill name
+4. Repo context (on demand) — read files as needed, not all upfront
+
+The agent goes from cold to fully contextual in under a second. No "let me explain..." No re-reading the same onboarding doc. Just start working.
+
+## What Makes This Different from LangChain
+
+LangChain, CrewAI, and similar frameworks are code-first. You define agents in Python, chain them with function calls, and deploy them as services. They're powerful for building AI products.
+
+Tinqs Studio is file-first. Agents are defined in markdown. Skills are markdown. Memory is markdown. Identity is markdown. Everything is in git, readable by humans, editable without code changes, and version-controlled.
+
+This matters for game teams because:
+
+- Non-engineers can contribute. The designer writes a skill for concept art. The PM writes a skill for sprint planning. No Python required.
+- Everything is auditable. git log shows who changed what, when, and why. Memory changes are commits. Skill updates are diffs.
+- It works with any AI tool. The same soul files and skills work in Cursor, Claude Code, or any tool that reads markdown. You're not locked into one framework.
+
+## The Stack
+
+| Layer | What | How |
+|——-|——|—–|
+| Identity | Soul files, company context | Markdown in git, loaded via CLI |
+| Memory | Cross-session context | Markdown in git, updated by agents |
+| Skills | Teachable workflows | Markdown playbooks, loaded on demand |
+| Tools | CLI, screenshots, vision | Go binary, one install per machine |
+| Git | 3D preview, LFS, SSO | Gitea fork with game-specific features |
+| Creative | Image gen, 3D models, video | fal.ai, Tripo, Sora 2 via skills |
+| Guardrails | Human approval gates | Branch protection, MR requirements |
+
+## Getting Started
+
+If you want to build your own agent harness for game dev:
+
+1. Start with a soul file. Write 50 words about your project's identity, values, and scope. Put it in your repo root as SOUL.md.
+2. Write one skill. Pick the workflow you repeat most — concept art generation, bug triage, build verification — and write the steps as markdown.
+3. Build a CLI identity command. Even a shell script that prints "project name, repos, services" gives your agent a warm start.
+4. Put everything in git. Not a database, not a SaaS tool. Git. You already have it.
+
+The rest — 3D preview, LFS management, OAuth SSO, creative pipelines — you can add as you need it. Or use Tinqs Studio, where we've already built it.
+
+—
+
+An agent harness isn't a product category yet. But it should be. The gap between "I have an AI model" and "I have an AI team member" is infrastructure — identity, memory, tools, context, guardrails. For game development, that infrastructure needs to understand binary assets, visual pipelines, and spatial systems. That's what we're building.
We gave our AI agents persistent identities, skill playbooks, and access to our entire knowledge base. This is how a 4-person game studio built an agentic workflow that punches above its weight.
+ +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.
+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.
+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.
+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.
+The two agents coordinate through the docs repo itself. One writes, the other reads. No API calls between them, no message queue. Just git.
+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:
+Giving the agent a persistent identity isn't theatre. It creates consistency across sessions. The soul file defines:
+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.
+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.
+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.
+ +