A team of AI coding agents that works like a company — on your own subscriptions, on your own machine.
TinyCorp is a desktop app. A Company is a folder on your disk, and every Employee in it is a long-lived coding-agent session — Claude Code, Codex or OpenCode — running on your own subscription, as you, on your machine. They claim tickets from a board, work in their own git worktrees, talk in a chat, and open pull requests you review without leaving the app.
It is not a chat window with a code block in it. It is a place where the work has a state you can see.
Every Employee is somewhere, and where they are is what they are doing: at a desk working, in the glass room because two of them are talking, at the counter because they are blocked or out of usage. The room is the status board.
- A Company of AI Employees, on your own subscriptions. You hire them, name them, pick their model and give them the repos they may touch. Each one is a real coding CLI you already have, signed in as you.
- A board, a chat and an office. Tickets with WIP limits, channels and threads with approval cards in them, and a pixel office where every Employee's position is their state.
- Real pull requests on real repos. An Employee gets a git worktree of its own, runs the checks your repo already has, and opens a PR you read and merge — or send back with a reason.
The files. Read what an Employee is working on while they work on it: the worktree's own tree, types on hover, go-to-definition, diagnostics from the project's own TypeScript, and an editor that saves back into the worktree.
- Bring your own subscription. There are no API keys. Sessions run on your login, and each
adapter strips the variables that would make its own CLI bill an API key instead:
ANTHROPIC_API_KEYandANTHROPIC_AUTH_TOKENfor Claude Code, everyCODEX*variable for Codex,OPENCODE_API_KEYandOPENCODE_AUTH_CONTENTfor OpenCode. The work is billed to the subscription you already pay for. - Plans, reviews and asks come before a merge. An Employee writes a plan you can send back before it writes code, and the things the Company treats as gated — merging, hiring, spending past a budget — wait for you in the Inbox. Nothing merges because an agent decided it was finished.
- Employees write into worktrees, never into your checkout, and never commit to your default branch. Work arrives as a branch and a pull request. Every ticket worktree keeps restore points you can send an Employee back to, including what was never committed.
- Claude Code, Codex and OpenCode are equals. A Provider is a folder and two lines, every adapter answers the same conformance suite, and one installed CLI is enough to use the app. Which product an Employee runs on is a per-Employee setting, so a Company can mix them.
- It is yours, on your disk. A Company is a folder with a SQLite database in it. There is no server, no account and no telemetry.
There is no published release yet — releases coming soon. Until then, build from source below;
if you were sent a private build, docs/beta.md is the page for you.
When a release exists, each platform gets:
| Platform | What you download | Notes |
|---|---|---|
| macOS | the .dmg |
Apple Silicon. Signed with a Developer ID and notarised by Apple, so it opens with a double-click. A release built before the signing secrets existed says so, and is opened the first time with right-click → Open (docs/RELEASING.md). |
| Windows | TinyCorp-Setup-<version>-x64.exe |
Windows 10 or later, x64. Installs for you alone and needs no administrator. SmartScreen warns once: More info → Run anyway. |
| Windows + WSL | the same installer | The app itself runs on Windows; a Provider CLI installed inside a distro is a first-class place for it to run — see docs/windows.md. |
| Linux | TinyCorp-<version>-x86_64.AppImage or TinyCorp-<version>-amd64.deb |
x86-64, Ubuntu 22.04 / Debian 12 / Fedora 39 or newer. The .deb declares its own dependencies and apt installs them; an AppImage cannot, so read docs/linux.md first. |
Nothing auto-updates yet. The app asks GitHub's public releases API whether a newer build exists and tells you where to get it; that one request is unauthenticated and carries nothing of yours.
Every platform needs Node 24 or newer and pnpm (corepack enable takes the version in
package.json).
git clone https://github.com/2yuri/tinycorp.git
cd tinycorp
pnpm install
pnpm dev # the appIf the window opens, you are done — there is nothing else to configure. To build an installer for the machine you are on:
- macOS (Apple Silicon):
pnpm packagewritesrelease/mac-arm64/TinyCorp.appand an unsigned DMG. Nothing is compiled;node-ptyships a darwin-arm64 prebuild. - Windows (x64):
pnpm package:winwrites the NSIS installer, from either host. Nothing is compiled. To develop on Windows, Git for Windows is worth having: the suite's real-git tests want it. - Linux (x86-64):
pnpm package:linuxwrites an AppImage and a.deb. This one does compilenode-ptyagainst Electron's headers, so it needsbuild-essentialandpython3, plus the libraries a packaged Electron app links against.docs/linux.mdhas theapt-getline, andlibsecret-1-0with a running keyring is the one to notice: without it TinyCorp refuses to store a secret rather than pretend to encrypt it.
CONTRIBUTING.md has the full per-platform setup, and the checks:
pnpm lint # Biome: the formatter and the linter in one pass
pnpm typecheck
pnpm test # Vitest; never spends a subscription
pnpm buildTo actually run an Employee you need one agent CLI — claude, codex or opencode — signed in
on your own subscription. Nothing in pnpm test needs one.
Your first Company is five steps, and the app walks you through them:
- Company — name it and point it at a folder. That folder is the Company: its database, its memory and its worktrees live there.
- Team preset — the shape of the office: Solo builder, Product squad, Full studio, or Start empty and hire by hand.
- Your team — the names and the models. Every seat is proposed on a Provider this machine can actually run.
- Repositories — where the work happens. Point it at a real repo you do not mind branches appearing in, or a scratch clone for the first hour.
- First ticket — give them something to build.
Then an Employee claims it, gets a worktree off your default branch, writes code, runs your repo's
own checks, opens a pull request and says so in #prs. You review the diff inside the app and
approve it, or send it back.
Electron and TypeScript: React in the renderer, PixiJS for the office, node-pty for the sessions,
node:sqlite for a Company's database with named migrations. The main process owns everything
real — the folder, the database, git, the CLIs, the secrets — the renderer only draws what
arrived over IPC, and preload is the bridge and nothing else. An Employee reaches back the other
way: its session is spawned pointing at a local MCP server, and it moves a ticket or posts to
chat by calling a tool on it. The app learns a session is busy, idle or waiting on you from the
Provider's own hooks, never by scraping a terminal.
src/main the Company engine, the Providers, the forges, IPC
src/preload the bridge
src/renderer React — office, board, chat, files, review
src/shared types and the IPC contract
docs/ product, decisions, specs, guides
ARCHITECTURE.md is the map: the modules, which way they are allowed to point,
and the invariants that hold everywhere. src/architecture.test.ts checks it against every import
in the repo, so it cannot quietly stop being true.
Every screen was designed in pen.dev before it was built, and
pnpm design:compare shoots every screen of the running app against how it drew before, so drift is
a number rather than an opinion.
An Employee runs on a Provider: the CLI product that does the work. This table is the catalogue
in src/shared/domain/providers.ts, which is the only place a
screen ever gets a Provider's name from — a test asserts that no renderer file names one.
| Provider | CLI | Sign in with | Reads your usage |
|---|---|---|---|
| Claude Code | claude |
Claude subscription, through claude login |
Yes |
| Codex | codex |
ChatGPT subscription, through codex login |
Yes |
| OpenCode | opencode |
Whichever account the boss already has, through opencode auth login |
No |
Adding one is meant to be a pull request, and pnpm provider:new <id> writes the three places it
touches: an entry in that catalogue, a folder under src/main/providers/ whose adapter passes
src/main/providers/provider-conformance.ts, and one
line in src/main/providers/provider-registry.ts. Every
adapter answers the same suite — spawn, resume, MCP injection, idle detection, usage limits, a clean
kill — so the second Provider cannot break somewhere the first one does not.
docs/providers.md is the guide, written for someone who has never opened this
repo.
Where a repo's pull requests live is a forge, read from the repo's own origin, per repo — so
one Company can hold repos on several. Adding one is the same shape
(docs/forges.md):
| Forge | CLI | Detected on | Sign in with |
|---|---|---|---|
| GitHub | gh |
github.com |
GitHub account, through gh auth login |
| GitLab | glab |
gitlab.com, gitlab.* |
GitLab account, through glab auth login |
A repo on a forge with no adapter still works for everything local — worktrees, branches, diffs, a local merge — and says plainly that it can open no pull request.
- It runs locally. No server, no account, no analytics, no crash upload. A Company is a folder. The one request TinyCorp makes on its own is an unauthenticated read of GitHub's public releases API, to notice a newer build; it carries no name of yours.
- TinyCorp does not hold your credentials. It never stores a subscription login or a forge
token, never writes one into a config of its own and never passes one as an argument. The CLIs own
their auth: you sign in with the CLI itself —
claude /login,codex login,gh auth login— and the app spawns a process that is already signed in. To answer are you signed in? it runs the CLI's own status command —claude auth status,codex login status,opencode auth list— and never opens the credential file. - Secrets live in the OS store. One store with one backend per platform
(
src/main/platform/safe-storage-secrets.ts): the login keychain on macOS, DPAPI on Windows, libsecret on Linux. The encrypted blobs sit in the app's ownuserData, never in the Company folder people zip and hand to each other. On a desktop where encryption would not really be encryption, TinyCorp refuses out loud. - Environment values never reach an Employee. The names are rows in the database; the values are in the OS store, read at one moment only — the child process a run spawns — and both its streams come back with every value replaced.
- An Employee is not sandboxed, and that is the deal. It can do what you can do in a terminal. The limits on it are the app's gates and the Provider's own permission prompts. Prompt injection is a real risk here: a ticket, a PR comment or a README in a repo an Employee reads is data, and an Employee that treats it as an instruction is a bug worth reporting.
SECURITY.md is the whole attack surface, what is already known and not a finding,
and how to report a vulnerability privately.
Pull requests are welcome, and a new Provider or a new forge is the one we are actively hoping for: both are a catalogue entry, a folder and one registry line, and the conformance suite tells you what is still missing.
CONTRIBUTING.md— setting up on macOS, Windows, WSL and Linux, your first pull request step by step, the four tiers of test, the sign-off and the title formatARCHITECTURE.md·docs/engineering.md— where a change goes, and how the TypeScript in it is writtendocs/providers.md·docs/forges.md— the two guidesCODE_OF_CONDUCT.md— Contributor Covenant 2.1docs/README.md— every document in the repo, one line each
Commits are signed off (git commit -s, the DCO — there is no
CLA), and a pull request title is Conventional Commits with the ticket as its scope:
feat(T182): the office remembers where everyone was sitting.
TinyCorp is licensed under the Apache License 2.0.
NOTICE carries the credits. The Company memory — a git-backed markdown wiki with a
derived index — follows the design of ai-memory by Fabio
Akita (MIT); what was taken is the shape rather than the code.
ponytail (MIT) is vendored under tools/bench/ so that
one arm of pnpm bench:tokens measures the real ruleset instead of a paraphrase of it, and its
insistence on isolating the arms and publishing the limitations is what
docs/bench-tokens.md is modelled on.




