Background coding agents

Ramp and Uber built their own coding-agent factories. You can just plug one in.

FactoryKit turns plain-language tasks into evidence-backed pull requests: an isolated AI coding agent implements the change, runs your checks, and QAs it in a real browser, recorded. No local dev environment, ever.

Book a demo

Fig. 1 — A task enters, the factory works inside a sealed boundary, evidence comes out.

The best engineering orgs already run a second shift. They had to build it. You don't.
~40%	of merged PRs at Ramp are written by their in-house agent	Ramp · Inspect
~1,800	agent-written changes shipped per week at Uber	Uber · Minion
90%	of the Fortune 100 use a background coding agent	GitHub · Copilot

How it works

The PR is the approval gate.

No new workflow to adopt: work arrives where your team already reviews it. Fig. 1 above is the whole line; the three figures below are detail views of each station.

1 · Describe the task

Describe it in plain language, or feed it in from Linear: a ticket becomes a task. Point FactoryKit at one repo or several, and pick the AI coding agent per task: Claude Code, Codex, Grok Build, or Kimi Code.

Fig. 2 — One task, every repo it touches, cloned side by side.

2 · The factory works

An isolated sandbox clones your repos, implements the change, runs your repo's own checks with fix attempts, self-reviews, then QAs UI changes in a real browser, recorded.

Fig. 3 — Your checks run inside the boundary, with fix attempts when one fails.

3 · Review evidence-backed PRs

One pull request per changed repo, with the QA recording attached. Follow-up messages stack commits onto the same PRs.

Fig. 4 — One pull request per changed repo, carrying its own proof.

Intake

From PRD to pull request.

Work enters the factory the way it already enters your team: specs, tickets, and logged bugs. It leaves as PRs.

Hand it the spec PRD → PR

Paste a PRD as the task. The factory implements it across every repo it touches and opens one PR per changed repo.

Point it at the board Ticket → PR

Connect Linear or Jira: a labeled ticket becomes a task, and the finished PR lands back on the ticket, ready to review. Or tag the agent in Slack.

Route it the bug Bug → PR

A logged bug becomes a fix run: the factory patches, re-runs your checks, QAs the fix in a real browser, and the PR is ready to review and merge.

Work in: Linear, Jira, Slack
Code out: GitHub
Agents: Claude Code, Codex, Grok Build, Kimi Code

Questions, answered

Built for the questions your team will ask.

Every PR ships with evidence.

“Agent PRs are slop.”

Your repo's checks run with fix attempts, the agent self-reviews, and UI changes are QA'd in a real browser with the recording attached to the PR. Reviewers can watch the change working before they read the diff.

You could. It costs a platform team.

“We could build this ourselves.”

Sandbox infrastructure, image caching, credential plumbing, browser QA, then permanent maintenance. FactoryKit is a GitHub App you connect today.

The agent improves with every task.

“An agent doesn't know our codebase.”

Key decisions and caveats from every run persist to a team-wide shared memory, so the next task starts smarter, for everyone on the team. Seed it by importing shared context from Notion, Jira, or Linear.

The full list

Everything the factory does.

Task in, PRs out. Submit a task and close the tab; the finished pull request waits for you.
Recorded browser QA. Every UI change ships with a video of it working in a real browser.
Parallel tasks. Every task runs in its own isolated sandbox, so queue several at once.
QA behind your login. Sign in to your app once; later runs test the signed-in pages too.
Follow-ups on the same PR. Reply like you would to a teammate and new commits stack on.
Your checks decide done. It runs your repo's lint, types, and tests, and fixes its own failures before you see a PR.
Multi-repo tasks. One task can touch the API and the frontend; each changed repo gets its own PR.
Intake from anywhere. A Linear ticket, a Slack mention, a screenshot, or a plain sentence.
Your pick of agent. Claude Code, Codex, Grok Build, or Kimi Code, chosen per task.
Bring your own keys. Add your Anthropic, OpenAI, Azure OpenAI, xAI, or Kimi key, or connect a Codex subscription; the provider bills you directly.
It can't wreck your repo. No merging, no pushing to your default branch; the worst case is a PR you close.
PRs that explain themselves. Every description carries a summary, verification steps, and honest caveats.
No junk PRs. A run that changed nothing opens nothing.
House rules, remembered. Per-repo notes and commands that every future run follows.
Live narration. Watch the agent reason through the work in plain prose, or check back later.
Nothing to install. No CLI, no plugin, no local checkout; any browser works.
Grant one repo to start. Access is a GitHub App install you scope and revoke in GitHub.
Self-improving agent. Key decisions and caveats from every run persist, so the next task starts smarter.
Team collaboration. Invite teammates by email; everyone shares the team's repos, runs, and history.
Cloud MAX. No local dev environment at all; the entire workflow runs in the cloud.

The creators

We built it to run our own companies.

FactoryKit is from the team behind Hashnode and Bug0: the internal factory that keeps both shipping with 1 or 2 engineers. That factory became the product. FactoryKit runs Hashnode, one of the largest developer publishing platforms.

Sandeep Panda, co-founder — X, LinkedIn
Syed Fazle Rahman, co-founder — X, LinkedIn

Your backlog isn't getting shorter.

Book 30 minutes and watch FactoryKit clear a real ticket from your repo, live. Book a demo.