Run it your way.
The fix run is the product. Where it executes, whose model it calls and who pays for the tokens are yours to choose — and in three of the four modes, your source code never reaches us.
Where your code goes, per mode
Follow the source code chip. It sits in Parsemend's column in exactly one of these four diagrams.
Parsemend triages events into a fix queue. Your agent claims a run, reads your source where it already lives, calls whatever model you point it at, and posts the patch back.
Parsemend drives the state machine and assembles the context bundle, which transits to your provider under your credentials. The bundle is not retained.
The CLI pulls the context bundle for one issue and runs the whole loop on your machine. Your source never crosses the network except to the provider you chose.
Parsemend reads the repository through its GitHub App, runs the fix on its own infrastructure with its own model credentials, and opens the draft pull request.
What you're actually paying for
If you bring the agent and the tokens, the obvious question is why you would pay us anything. This is the answer.
Context bundles
The stack trace, the in-app frames, the surrounding source, the breadcrumbs and the recent commits that touched those lines — assembled into one payload an agent can act on without crawling the repo.
Fix-run state machine
Root cause, then solution, then coding, then change description. Each step is a checkpoint. A run that dies at step three resumes at step three rather than starting over.
Confidence gating
Every step emits a confidence score. Below the project's threshold the run pauses and waits for a human instead of confidently shipping a wrong patch.
Draft PR post-back
The patch arrives as a draft pull request against the right branch, with the root cause and the reasoning in the description. It never merges itself.
The four modes, side by side
| Capability | Bring your own agent | Your API keys | Local CLI | Managed |
|---|---|---|---|---|
| Where things run, and who pays | ||||
| Where the run executes | Your infrastructure | Parsemend | Your machine | Parsemend |
| Who pays for tokens | You, directly to your provider | You, directly to your provider | You, directly to your provider | Parsemend (included in the plan) |
| Model choice | Anything you run | Anthropic · OpenAI · Gemini · Ollama | Anthropic · OpenAI · Gemini · Ollama | Chosen by Parsemend |
| Source seen by Parsemend | Never | Streamed, never stored | Never | Read via GitHub App |
| Setup | ||||
| Needs a GitHub App installation | No | No | No | Yes |
| Needs your own model credentials | Yes | Yes | Yes | No |
| Needs you to operate an agent | Yes | No | No | No |
Which one should you pick?
- Bring your own agent
- Teams who already run an internal coding agent and want it fed real, triaged work.
- Your API keys
- Teams who want the orchestration without operating an agent, and who already have provider accounts.
- Local CLI
- Anyone who cannot send source code to a third party, and anyone who wants to watch the run happen.
- Managed
- Teams who want the outcome and are comfortable granting repository access.
The trade-off is real: the modes that keep your code private also make you responsible for the model bill, the rate limits and the failures. Managed mode is genuinely easier. It is also the only one where you have to trust us with the repository.
Frequently asked questions
If I bring my own agent and my own tokens, what am I paying for?
The framework: context bundles that assemble the stack trace, in-app frames, surrounding source and recent commits into one payload; a resumable fix-run state machine; confidence gating that pauses a run rather than shipping a low-confidence patch; and draft PR post-back. You are paying for the harness around the model, not the model.
Which models can I use?
Anthropic, OpenAI and Gemini via their APIs, or any model you serve yourself through Ollama. In managed mode Parsemend chooses the model, because Parsemend is paying for the tokens.
Does Parsemend ever see my source code?
Only in managed mode, where it reads the repository through a GitHub App installation. In bring-your-own-agent and CLI modes your source never leaves your infrastructure. In your-keys mode Parsemend assembles the context bundle and transits it to your model provider without retaining it.
Can I switch modes later?
Yes. The mode is a per-project setting, not a plan. The fix queue, the issue data and the state machine are identical across all four; only the execution location and the credentials change.