Questions people actually ask

1. What is FULCRUMAXE?

It is a team of AI agents that lives inside your GitHub repository and does routine programming work — bug fixes, small features, documentation — while you stay the person deciding what gets built.

"Agent" here just means a copy of an AI model given one job and a set of tools. FULCRUMAXE runs 26 of them in different roles: one writes code, one reviews it, one checks it for security problems, one keeps the plan straight. They hand work to each other roughly the way a small development team does.

You install it on your own machine and point it at your own repository. There is no website to sign up for and no service to buy.

2. What does it actually do all day?

It works through a queue. Each item takes the same route:

1. You describe what you want as a GitHub Discussion — a thread on your repo. Plain prose is fine.
2. A planning agent turns it into a spec: what to change, and what "done" means.
3. A coding agent writes it in its own private copy of your repository, then opens a pull request — GitHub's "here is a change, please review it" mechanism.
4. Reviewer agents read it. If they find problems, it goes back to the coding agent to fix. Anything touching passwords, keys or the safety rules gets a second, security-specific review.
5. Only then does it merge into your main branch.

Several items are usually moving through that route at once — one change being written while another is under review — up to limits you set. There are caps on how many implementations run in parallel and how many agents any one role may have going, so a busy queue costs more in AI usage but does not spawn without bound.

When the queue runs dry, it reads its own codebase, writes up the problems it finds, and puts those in the queue too. That is why the public discussion list is full of the project criticising itself.

3. Does it decide what to build, or do I?

You do. It works from a queue, and the queue is yours: you add what you want, and you can close anything you don't. It is built for one developer handing off the routine half of the job, not for handing over the project.

Setup is deliberately built the same way. Provisioning stops after the first phase and waits for you, because the next step is a decision about your backlog and a machine guessing at that is not helpful.

4. Is it safe to point at my repository?

The honest answer is that it is built to make the dangerous things hard rather than to promise they are impossible. Three things stand in the way:

• It never edits your files directly. Each agent gets its own separate checkout of the repository to work in — a "worktree". Your actual working copy is untouched.
• A permission hook blocks the destructive moves. It stops an agent writing outside its own worktree, switching what your repo is pointed at, or merging its own work around the review step.
• Nothing reaches your main branch unreviewed. Every change goes through review first, and the merge gates are labels applied by the machinery rather than an agent's opinion of its own work.

What it is not is an AI committing straight to your main branch and hoping. Every change arrives as a pull request you can read, argue with, or close.

5. If it runs on Claude Code, how is it different from just using Claude Code?

It is not an alternative to Claude Code — it is built on top of it. FULCRUMAXE installs as a Claude Code plugin, and every agent it runs is a Claude Code session it starts for you. If you use Claude Code today, this is a way of running it, not a thing to switch to.

The difference is how those sessions are used. On your own you run one at a time, you drive it, and it stops when you stop. FULCRUMAXE runs many of them in fixed roles, unattended, against a queue you filled earlier — and it makes them check each other's work, so the session that writes a change is never the one that approves it.

What comes back is different too. Not a suggestion in your editor, but a pull request with a review trail attached, waiting in the place your team already looks. Discussions are the specs, pull requests are the work, Issues are the log — so there is no second tool to learn on top of GitHub.

Against an in-editor assistant like Copilot the gap is wider still: those wait for you to type. This one works while you are asleep.

6. Which AI does it use, and where does my code go?

Claude, by default — each agent is a Claude Code session started with an AI credential you supply, which is the same relationship described above. The underlying runtime can also talk to other OpenAI-compatible providers.

Your code goes to that AI provider, because that is what asking a model to read and change your code means — the same as any AI coding tool. Beyond that it talks to GitHub, and to Slack if you set up a webhook for notifications.

There is no FULCRUMAXE server in the middle. Nothing is hosted for you, so your code is not passing through anything we operate on its way to anywhere.

7. What does it cost?

Nothing to us. It is free and open source under the AGPL-3.0 licence, and there is no paid tier to upgrade to.

What it does cost is AI usage, billed to you by whichever provider you use, because it is thinking constantly rather than only when you press a key. On this project's own work the median merged change costs about $29 of model usage — but the spread is wide, a hard one runs several times that, and your repository is not this one. Treat it as a rough sense of scale, not a quote. The full record shows the distribution.

8. What do I need to start?

On your machine: Claude Code, an AI credential of your own, the GitHub command-line tool (gh) signed in, plus Node.js and Python 3. On GitHub: a repository with a real remote it can push to.

Then it is three lines typed into Claude Code — the roles and everything they need ship inside the plugin, so there is nothing to clone.

/plugin marketplace add fulcrumaxe/fulcrumaxe
/plugin install fulcrumaxe@fulcrumaxe
/coldstart --path /path/to/your/repo --name your-project

If you would rather read the plan before anything happens, the setup script has a --dry-run mode that prints every step and changes nothing at all — and you can run it here in the page without installing anything first.

9. What happens when it gets something wrong?

Usually review catches it and sends it back. That is not a rare event and the number is published rather than hidden: review currently rejects about 37% of the work on first pass, and those rejected pull requests stay readable in full, including the reviewer's reasoning.

A high rejection rate is the system working. The failure worth worrying about is the opposite one — reviewers that pass everything.

When something gets through anyway, it is a pull request in your repository like any other: revert it, or file the bug and let the queue pick it up. And because agents work in isolated copies, a confused agent damages its own scratch checkout rather than your working tree.

10. Is it finished? Should I use it on something that matters?

It is not finished, and the project says so on its own front page. It runs daily and is CI-tested, but it is experimental: overlapping scripts, documentation that lags the code, conventions still settling. Expect it to keep changing shape.

There is also no hosted version, no multi-tenant support and no billing. You run it on your own infrastructure and your own AI budget, or you don't run it.

A fair way to start: point it at a real but not critical repository, leave the review gates on, and read the first dozen pull requests properly before you trust the thirteenth.