Fork, Don't Build: The Age of Agents Doesn't Need New Tools

The Pattern

We're a four-person game studio. We don't have time to build a git platform, a coding agent, and a game engine from scratch. Nobody does. But we can take something that already works — something with years of battle-testing, thousands of contributors, and millions of users — and change it from the inside.

The pattern is simple:

1. Find an open-source tool that does 95% of what you need

2. Fork it

3. Add the 5% that makes it yours

4. Stay close to upstream so you get their fixes for free

We've done this three times.

Fork 1: Gitea — Our Git Platform

Gitea is a self-hosted git server. Single Go binary, MIT license, 45k GitHub stars. It handles repos, issues, pull requests, CI, LFS — everything a team needs.

We forked it and built Tinqs Studio. Our changes:

• 3D asset preview — click a .glb file and rotate the model in your browser
• HTML file preview — rendered in a sandboxed iframe, not raw source
• Agent API — six endpoints that let AI agents submit tasks, push code, and open PRs
• OAuth2 SSO — one login for git, the game, and every tool
• Credits system — monetize AI inference without hiding features behind paywalls

Total lines changed from upstream: about 2,000 out of Gitea's 500,000. That's 0.4%. We modify templates, add Go modules, and tweak CSS variables. We never touch the database schema — we ride upstream's migrations. When Gitea releases 1.27, we rebase, fix conflicts, and ship.

The alternative was building a git platform from scratch. That's a multi-year, multi-million dollar project. Or using GitHub/GitLab and accepting their limitations. Neither option gives you the ability to embed AI agents directly into the platform.

Fork 2: Pi — Our Agent Runtime

Pi is an open-source coding agent. 51k stars, MIT license, TypeScript. Four core tools (read, write, edit, bash), a minimal system prompt, and an extension system.

We forked it and added four extensions:

• tinqs-provider — routes inference through our DeepSeek V4 proxy ($0.28/MTok vs Opus at $15/MTok)
• tinqs-tools — Gitea API, fal.ai image generation, vision preprocessing
• tinqs-ci — reads CI pipeline status and logs, polls for completion
• tinqs-guardrail — 29 safety patterns blocking dangerous commands

Each extension is a single TypeScript file. No npm dependencies. The core Pi code is untouched — we only add files.

The alternative was building our own agent from scratch. That means writing tool-calling logic, context management, streaming, retry handling, conversation threading — months of work to reinvent what Pi already does. Or using Claude Code / Codex as a black box and accepting that you can't add a Gitea API tool or a budget cap.

Fork 3: Godot — Our Game Engine

Godot is an open-source game engine. We forked 4.6.2 and added nine C++ modules that turn the engine into an agent-aware runtime:

• agent_api — HTTP server inside the engine, so agents can query game state
• agent_vision — screenshot capture for AI vision pipelines
• agent_console — programmatic access to the engine console
• agent_replay — record and replay game sessions for testing
• agent_analytics — PostHog event tracking from inside the engine

These modules compile into the engine binary. A vanilla Godot user never sees them. An agent can connect to the running engine over HTTP, take a screenshot, read the scene tree, execute a console command, and capture the result — all without touching the editor UI.

The alternative was building an engine integration from scratch. Or worse, building a custom engine. We'd still be writing a renderer instead of making a game.

Why Forking Beats Building

You inherit decades of work

Gitea has handled millions of git pushes. Godot renders millions of frames. Pi has processed millions of LLM tokens. That battle-testing is free when you fork. When you build from scratch, you spend your first year rediscovering bugs that were fixed upstream in 2019.

You get free maintenance

Every upstream release brings security patches, performance improvements, and new features — written by hundreds of contributors we don't pay. Our job is to rebase, resolve conflicts, and test. That's an afternoon, not a quarter.

You stay focused

Building a git server from scratch means worrying about pack-file format, SSH key management, webhook delivery, and a thousand other things that have nothing to do with AI agents. Forking means you only think about the 5% that matters to you. The other 95% is someone else's problem.

Agents work better on real platforms

An agent that pushes to a real Gitea instance — with real CI, real code review, real permissions — produces work that humans can actually review and ship. An agent that pushes to a toy demo platform produces demos.

The whole point of AI agents is to participate in real workflows. Real workflows run on real tools. If you want agents in your git workflow, put them in your git server. If you want agents in your game pipeline, put them in your game engine.

The 0.5% Rule

Across all three forks, our total changeset is less than 0.5% of the upstream code. Tinqs Studio: 0.4% of Gitea. Pi extensions: 900 lines added to a 15,000-line codebase. Godot modules: 2,000 lines added to a 2-million-line engine.

This isn't a coincidence. If your fork touches more than 1% of upstream, you're doing too much. Either the upstream tool is wrong for the job, or you're not trusting it enough. The power of forking is that you don't have to understand the whole codebase. You find the extension points, add your code, and leave the rest alone.

What We're Not Doing

We're not building a new IDE. Cursor and Claude Code exist. We're not building a new LLM. DeepSeek and Claude exist. We're not building a new cloud platform. AWS exists.

We're building the layer that connects them. The git server that speaks agent. The coding agent that speaks Gitea. The game engine that speaks HTTP. Each fork is a bridge between an existing tool and the agentic future — not a replacement for either.

The Bet

The age of agents doesn't need more agents. It needs better platforms. Platforms that understand agents as first-class users — with API endpoints, safety rails, and lifecycle management. Those platforms already exist as open-source projects. They just need someone to fork them and add the wiring.

That's the bet. Fork, don't build. Modify the foundation, don't stack another layer on top. Let the upstream community handle the 99.5% while you focus on the 0.5% that makes it yours.

---

Tinqs Studio is our Gitea fork, open for game teams and indie studios. We're building Ariki — a survival colony sim — using every tool described in this post. If you're interested in self-hosted game development with built-in AI agents, come take a look.