source control · review · merge queue

Agents write the changes. You decide what lands.

jones is a git host, review system and merge queue for teams whose code is mostly written by agents. Every change is classified by your policy, checked, reviewed by agents, and decided by a person when it matters. It runs on your own Cloudflare account.

Install with your agent See how a change lands

change c-4k2 · version 3 for/main/retry-fetch

Retry 5xx responses in the fetch client

Standard
stacked on c-4j9
task T-412

Pushed 3 commits; a rebase onto main carried the approval
Classified Standard: one package, generated files not counted
Checks passed unit · lint · e2e
Reviewed intent, correctness, security; 1 finding resolved in version 2
Waiting on a member of maintainers

self-hosting

jones is built with jones

Since October 14, 2026, every change to jones has gone through its own tasks, checks, reviewers and merge queue.

one platform

It runs entirely on Cloudflare

Git lives in Artifacts. Everything else is Workers, Durable Objects, D1 and Queues, behind Access.

01 · how a change lands

Six steps from git push to main, and a record of every one.

step 1

Push

A branch pushed to for/main/<topic> opens a change. Every later push is a new version, force-pushes included. No hook, no Change-Id.
step 2

Classify

Your policy sorts the change into Patch, Standard, Significant or Restricted by size, paths and dependencies. Generated files don't count toward size.
step 3

Check

Required checks run on Workers Builds or a Linux executor. When main moves but none of a check's inputs did, the re-run is skipped.
step 4

Review

Reviewer agents check that the change does what it says, then correctness and security. Findings anchor to lines and carry across versions.
step 5

Decide

Small, tested changes merge on their own. The rest wait for a person or a group, and Restricted paths always do. One decision: approve, revise or reject.
step 6

Land

One merge queue per project, by squash, rebase or merge commit. A git note on main records the class, the checks, the verdicts and who decided.

02 · changes, versions, stacks

One way in, for people, agents and bots.

A topic is a change

Push a branch of any number of commits and it's reviewed as one unit. Amend, rebase and force-push as much as you like: the change keeps its identity, and each push is a version you can diff against the last.

Stacks without restacking

Build on another open change and jones notices. Each change is decided on its own and lands in order. When a parent gets a new version or squash-merges, jones rebases the children itself, and a resolver agent takes any conflicts.

Tasks when you want them

A task ties an intent to the agents attempting it. Start several attempts and keep the best. Each attempt works in its own repository, with its own short-lived token, and its change is reviewed against the task.

$ git commit -m "Retry 5xx responses in the fetch client

Retries with backoff, up to three times.

Jones-Task: T-412"
$ git push origin HEAD:for/main/retry-fetch
$ jones status
c-4k2  v1  Retry 5xx responses…   Standard   checks running
       stacked on c-4j9 (inferred)

Title, description and task come from the commit and its trailers. The jones CLI and MCP tools change them without a new commit.

03 · policy

Your rules live in the repo, and change the way code does.

jones reads policy only from main, never from the change under review, and a change to the policy is itself Restricted. Every project sets its own classes, approvers, reviewers and merge method.

Patch: Small, tested and in scope. Merges on its own once checks and reviewers pass.
Standard: A typical change. One approval from the project's approvers.
Significant: APIs, schemas, dependencies, or a change across directories. Approval, with the reviewers' findings in front of the approver.
Restricted: The policy itself, the merge path, CI config, agent instructions. Always a person. Never automatic.

# .orchestrator/policy.yaml
classes:
  patch:
    max_changed_lines: 50
    require_tests: true
  restricted:
    paths:
      - ".github/**"
      - "codegen/**"
      - "AGENTS.md"
generated:
  - "src/generated/**"
approval:
  required_for: [standard, significant, restricted]
  approvers: ["group:maintainers"]
merge:
  method: squash

04 · agents and people

Agents do the work. People keep the last word.

Reviewers on your models

Reviewer agents run behind a provider port: Anthropic's models, or others through AI Gateway and Workers AI. Each project picks its own.

A resolver for conflicts

When main moves under a change and the merge conflicts, a resolver agent rebuilds it, and the result is reviewed like any other version.

Bots with their own identity

Release and regeneration bots push as service identities, and their kinds of change follow their own rules. A clean regeneration can merge with no one waiting on it.

An inbox, not a firehose

People see what's waiting on them: the diff, the checks, the findings and the intent, on one page, with one decision to make.

$ git notes --ref=jones show main
change:   c-4k2 v3   task T-412
policy:   v2   class: standard
checks:   unit ✓  lint ✓  e2e ✓
review:   intent ✓  correctness ✓  security ✓
decision: approved by [approver] (maintainers)

05 · built on cloudflare

No servers to run. Nothing outside your account.

Artifacts: Git repositories, forks and scoped tokens
Workers: The API, the console and the review app
Durable Objects: Changes, tasks, merge queues and inboxes
D1 and Queues: The index, and the events that drive it
Workers Builds: Checks on every candidate, deploys from main
Access: Sign-in, groups and who may decide

06 · self-host

Your team's instance, on your account, with your changes.

One instance per team, many projects. One sign-in, one inbox and one set of reviewers across your repos, each with its own policy and queue.
Fork it and extend it. Your instance runs your fork of jones, so you can change anything. Upstream releases merge in as a jones change, and you approve them.
An agent installs it. Point your coding agent at install.md. It asks a few questions, provisions everything, and stops only for the steps that need the dashboard.
MIT licensed. Use it, change it, ship it.

# ask your agent
Read https://jones.science/install.md and set up
jones for our team.

# or run it yourself
$ npx jones init