Disclosure: I work on Git A. The checklist in the first part works with any setup. The last part shows how Git A does it.
More teams are assigning issues to AI coding agents and getting a pull request back. Usually the agent runs in the cloud and uses a model you pay for with your own API key, often called BYOK (bring your own key). That's the right direction. You choose the model and the provider bills you directly.
But "assign the issue and wait" goes wrong in some predictable ways. Here is the checklist we use. Every point holds whatever tool you run.
1. Write the issue like a ticket for a new teammate
The agent only knows what the issue says. Four short parts are enough:
- Title: one change, in plain words. "Add rate limiting to /login", not "auth stuff".
- Why: one or two sentences. It helps the agent choose between two reasonable fixes.
- Where: the files, folders or endpoints involved, if you know them.
- Acceptance criteria: a short list of things that can be checked. "Returns 429 after 5 attempts in a minute." "Existing login tests still pass." "New test covers the limit."
The acceptance criteria are what a review checks the result against. Without them, "done" means whatever the agent decided.
2. Keep your model key away from the agent
The agent needs to call the model. It does not need to hold the key. If the key sits in the agent's environment, anything the agent runs can read it, including a dependency's install script. Prefer a setup where the platform makes the model calls on the agent's behalf, or where a gateway you control holds the key.
If you already run a gateway such as LiteLLM, point the agent at the gateway. Then you get one place for logging, budgets and switching models.
3. Cap every run
An agent stuck in a loop can burn an afternoon of tokens. Set two limits before the first task:
- the longest a single run may take, in minutes;
- the most a single run may spend on the model, in dollars (an estimate is fine).
When a run hits a limit, it should stop and tell you. It should never quietly carry on.
4. A fresh machine per task
Run each task on a clean machine or container that is thrown away afterwards. Then one task can't leave files, caches or credentials behind for the next. It also makes failures easy to reproduce: same issue, same starting point.
5. Tests are part of the change
Ask for tests as part of the task, not as a follow-up. Then run your checks, the same CI a human change would go through, on the agent's branch. A green run of the agent's own tests alone proves little.
6. Review against the issue, by someone other than the author
The agent that wrote the change shouldn't be the one that approves it. A separate review, by a person or a second agent with its own instructions, should answer one question: does this change do what the acceptance criteria say, and nothing else?
7. Some files always wait for a person
Choose a short list of paths an agent can never change without a human approving: CI workflows, deploy scripts, lockfiles, auth code. An agent should also never approve its own change.
8. One change back, not a pile of commits
What you want back is one reviewable change: the diff, the tests, the check results and a short summary of what was done and why. Then approving it is a decision, not an archaeology project.
9. A big red stop button
At some point you'll want every running task stopped at once. Make sure you know where that button is before you need it.
How Git A does it
Git A is built for many AI agents working on the same code at once. Every change lands on main without the rejected-push retry loop. The second half is the Agent factory: you hand an issue to an agent and get back one finished change to approve.
What the flow looks like in Git A today:
- Connect your model once per organization: Anthropic, OpenAI, Google Gemini, Google Vertex AI, Amazon Bedrock, Azure OpenAI, OpenRouter, Mistral, xAI, DeepSeek, Groq, Together AI or Fireworks AI. You can also use your own gateway (OpenAI or Anthropic format) or a model on your own machine (Ollama or vLLM) on your own runners. Choose Save and test. Your provider bills you directly, and the agent never sees your key.
- Create an agent: name it and pick the repositories it may work on. Under When it's done, choose Ask me (you approve every change) or Land by itself when checks pass. Keep Every change comes with tests ticked. You can choose the program it runs: Claude Code, Codex, Gemini CLI, Goose, OpenCode, your own command or your own container image. Set limits per run.
-
Write the issue and hand it over: assign it, @mention the agent, or run
ga issue assignfrom the command line. - Watch it work: it works on a fresh machine of its own (Git A's or your own runners), writes the code and its tests, and runs your checks. A separate review checks the change against the issue. If the agent has a question, it asks you on the issue.
- Review and land: you get one proposal. Approve it, or let it land when the checks pass.
Agents are free: there are no per-agent seats. You prepay credit for what they use (machine minutes, storage). The model bill stays with your own provider.
The full step-by-step guide is at git--a.com/docs under "Hand an issue to an agent". Everything above is described there as it works today.
If you run several agents on one repository and want to see what the rejected-push loop costs you now, git--a.com/measure has a bash script that counts it on your own repo, using a throwaway branch. It never touches main and sends nothing to us.
What's on your checklist that isn't on mine? I'd like to hear what went wrong the first time you let an agent take an issue.
Top comments (0)