Compare Felan

What Is a Background Agent?

A background agent is an AI coding agent that works without anyone watching. It starts from an event, a schedule, or a request, runs in its own isolated environment instead of a developer's laptop, and hands back a result for a person to review.

Next: What Is an AI Dark Factory?

Local Agent vs. Background Agent

  • Starts from

    Local agent: A developer typing a prompt

    Background agent: An event, a schedule, or a request

  • Runs on

    Local agent: The developer's laptop

    Background agent: Its own isolated environment

  • Attention

    Local agent: Someone watches and steers

    Background agent: Nobody watches; a person reviews the result

  • Scale

    Local agent: A few sessions, capped by the laptop and by what one person can watch

    Background agent: As many runs as your infrastructure and budget allow

  • Best for

    Local agent: Hard problems that need judgment

    Background agent: Repeatable work nobody should have to watch

How It Works

1

A Trigger Starts It

A pull request, a failed build, an alert, or a schedule starts a run. A person can also delegate a task.

  • PR opened
  • Build failed
  • Alert fired
  • Schedule
2

It Gets Its Own Environment

The agent runs isolated, with the repository, tools, and only the credentials the task needs.

One environment per run

  • Agent
  • Tools
  • Scoped credentials
3

It Does the Work

It reads the code, makes changes, runs the tests, and tracks what it spent.

  • Reads the code
  • Makes changes
  • Runs the tests
4

A Person Reviews It

The result comes back as a pull request, a report, or a comment for someone to check.

A person reviews the result

Who Runs Background Agents Today

  • Stripe · Minions

    A run starts from a Slack message in an isolated devbox and ends in a pull request that passes CI.

    1,000+

    PRs merged each week, all human-reviewed

    Stripe's Minions post

  • Ramp · Inspect

    Cloud sessions get the same tools an engineer has locally. Separate agents fixed about 100 security issues in 6 days, with people only at PR review.

    ~30%

    of PRs merged to frontend and backend repos

    Why Ramp built InspectRamp's security fixes

  • Spotify · Honk

    An agent inside Fleet Management writes code changes that roll out across thousands of repositories.

    1,500+

    merged AI-generated PRs

    Spotify's Honk post

  • Uber · Managed agents

    Agents review code, fix failing CI, and triage alerts. Uber tracks cost per merged PR and routes work across models to cut cost per session.

    9.4x

    weekly agent requests across Uber's agentic tools, February to August 2026

    Uber's software factory post

What Teams Delegate First

When Something Happens

  • Failed build triage
  • Incident investigation
  • Product checks after a PR
  • First-pass code review

On a Schedule

  • Dependency updates
  • Security fixes
  • Flaky test cleanup

When Someone Asks

  • Well-defined bug fixes
  • Small migrations

Where to Start

Pick One Task

Choose repeatable work that happens every week and affects a small part of the system.

  • Dependency update
  • Flaky test fix
  • Failed build triage

Define Done

Decide what a good result looks like before the first run.

  • CI passes
  • Tests cover the change
  • A person approves

Track Three Numbers

Expand to the next task once these hold for a few weeks.

Merged without rework
Share of runs
Review time
Minutes per PR
Cost
Per task

What to Watch

Cost Grows With Every Run

More runs and parallel tasks increase token spend.

  • No markup on tokens
  • Cheaper model for simple work
  • Cost per task shown

Access Needs a Boundary

An unattended agent can only do what its environment allows.

  • Isolated environment
  • Scoped credentials
  • Self-hosting option

Output Needs a Reviewer

Unattended work still ships under your team's name.

  • Pull request or report
  • Tests run first
  • Human approval

Mistakes to Avoid

  • Scope

    Mistake: Automating everything at once

    Instead: One well-scoped task, then the next

  • Context

    Mistake: Vague prompts

    Instead: Agent instructions, repo conventions, and good tests

  • Where it runs

    Mistake: A developer's laptop

    Instead: An isolated environment for every run

  • Access

    Mistake: Rules the agent is asked to follow

    Instead: Boundaries the environment enforces, with scoped credentials

  • Cost

    Mistake: Checking the bill at month end

    Instead: Cost per task from day one, with a cheaper model where it's enough

  • Review

    Mistake: Merging agent output unread

    Instead: A person approves every change

Build or Buy

  • Getting started

    Build: A few scripts, a CI job, and a local agent

    Buy: Connect repositories and pick a trigger

  • Keeping it current

    Build: New models, agent tools, APIs, and security risks every few months

    Buy: The vendor keeps the platform current

  • Who maintains it

    Build: Your engineers maintain the platform as well as your product

    Buy: The vendor maintains the platform; your team maintains its configuration

Background Agent Platforms Compared

  • Felan

    Models: All major providers, plus local and private models

    Where it runs: Managed cloud, or fully self-hosted on Enterprise

  • Devin

    Models: Hosted model catalog; no local models published

    Where it runs: Devin Cloud; Outposts keep the agent loop there

  • OpenHands

    Models: Any provider, plus local models

    Where it runs: Free Agent Canvas, or paid Teams and Enterprise self-hosting

  • Tembo

    Models: Hosted providers; custom inference endpoints documented for self-hosting

    Where it runs: Licensed self-hosted deployment; price not published

  • Ona

    Models: OpenAI models; other providers by exception on Enterprise

    Where it runs: Ona-managed VPC in your AWS or GCP account, on Enterprise

  • Claude Code

    Models: Claude models only

    Where it runs: Execution only, in beta; Anthropic hosts orchestration

  • OpenAI Codex

    Models: OpenAI models in the cloud; other models in the local CLI only

    Where it runs: Only the executor, built against the Agents API; OpenAI runs the agent loop

  • GitHub Copilot

    Models: Multi-model catalog GitHub includes with your plan

    Where it runs: Execution only, on self-hosted Actions runners

  • GitLab Duo

    Models: GitLab-managed models to pick from; your own models only if self-hosted

    Where it runs: Self-Managed or Dedicated for Government, with self-hosted models

  • Rovo Dev

    Models: Several Atlassian-provided LLMs in the CLI; local models not documented

    Where it runs: No published self-hosted runtime

  • Cursor

    Models: Curated hosted models; local models not documented

    Where it runs: Self-Hosted Machines run tools only; the agent loop stays in Cursor's cloud

  • Factory

    Models: Multi-model catalog, plus an open-weight pool

    Where it runs: Bring your own machine for compute; Factory still coordinates

  • Coder Agents

    Models: Major providers, plus OpenAI-compatible self-hosted endpoints

    Where it runs: Self-hosted by default, on every plan including Community

Common Questions

What is a background agent?

A background agent is an AI coding agent that works without anyone watching. It starts from an event, a schedule, or a request, runs in its own isolated environment instead of a developer's laptop, and hands back a result for a person to review.

What are the main background coding agent platforms?

Options include Felan, Devin, OpenHands, Tembo, Ona, Claude Code, OpenAI Codex, GitHub Copilot, GitLab Duo, Rovo Dev, Cursor, Factory, and Coder Agents. They differ in which models you can use, how tokens are billed, and whether the agent can run on your own infrastructure. Felan supports all major model providers, including local and private models. It adds no markup on tokens and runs on its managed cloud or fully self-hosted on Enterprise.

Is a background agent the same as an autonomous coding agent?

Mostly. An "autonomous coding agent" plans and acts on its own. A "background agent" runs unattended in its own environment, started by an event, a schedule, or a request.

Which companies use background agents?

Stripe's Minions produce over 1,000 merged pull requests a week, all reviewed by people. At Ramp, about 30% of pull requests merged to its frontend and backend repos come from its Inspect agent. Spotify's Honk has merged more than 1,500 AI-generated pull requests across its repositories, and Uber runs managed agents for code review, CI fixes, and alert triage.

Do background agents replace Cursor, Claude Code, or Copilot?

No. Developers keep their local agents and copilots for hard problems that need judgment. Background agents take the repeatable work that shouldn't need anyone watching.

What should a team delegate first?

Well-scoped work with a result someone can check: failed build triage, dependency updates, flaky test cleanup, first-pass code review, and well-defined bug fixes.

Are background agents safe to run on production code?

Isolation, credentials scoped to the task, and human review before merging reduce risk, but do not guarantee safety. Check each platform's controls and your own security requirements. Felan's Enterprise plan supports self-hosting for teams that need to keep code on their own infrastructure.

How do you keep background agent costs under control?

Pay provider rates with no markup on tokens, use a cheaper model for simple tasks and a top model for hard ones, run an agent built to use fewer tokens, and track the cost of every task.

Should we build our own background agent platform?

A strong team can build one. The ongoing cost is keeping it current as models, agent tools, APIs, and security risks change every few months, which takes engineers away from your product.

Keep Your Attention for the Hard Problems

Start with one repo and one recurring task.