Issue to Code
Multi-agent system

From issue to PR,
automatically.

Seven specialised agents with a human-in-the-loop checkpoint before any code is generated.

Sign in with GitHubRead the docs
TypeScript
React
Next.js
JavaScript
Vue
Svelte
Python
The pipeline

Watch seven agents do the work, live.

Each step streams to the UI as it completes. You can inspect what each agent saw and produced, and pause to approve the plan before any code is generated.

✓ Parser · extracted keywords, type=feature
✓ Locator · 8 relevant symbols retrieved
✓ Plan · 3 files to modify, 1 to create
‣ Awaiting your approval ...
✓ Approved by you
✓ Code Generator · 4 files rewritten
✓ Self-Reflect · all checks passed
✓ PR opened on GitHub → /pull/128
What makes it different

More than a code-completion tool.

A multi-agent pipeline, AST-aware retrieval, live streaming and human-in-the-loop checkpoints. Built for issue-to-PR work.

Multi-agent pipeline

Seven specialised agents — Parser, Locator, Plan, Code, Self-Reflect, Few-shot, PR Creator — each with one job.

AST-aware retrieval

Tree-sitter + symbol-level embeddings + dependency graph expansion. Not naive chunking.

Live SSE streaming

Every step, every retry, every status transition — pushed to the UI as it happens.

Human in the loop

The pipeline pauses on the plan. You approve, reject or instruct in natural language before any code is written.

Self-reflection

A second pass of the same model reviews its own output against the plan. Up to three retries before failing.

Encrypted tokens

Your GitHub access token is encrypted at rest with AES-GCM and only decrypted in memory at the moment of an API call.

Built on the open stack

Tools you already know, glued together with care.

Anthropic and OpenAI for inference, FastAPI and Next.js for the surface, Postgres, Redis and Qdrant for state, LangChain & LangGraph for orchestration. Drag the cloud — it's yours.

One agent at a time

You stay in the loop, the agents do the rest.

Each agent has a single, narrow job. The handoff between them is visible in real time, so you always know who is doing what.

Parser·just now

Extracted issue type, keywords and affected areas.

  • src
    • components
      • auth
        • login-form.tsx
        • oauth-buttons.tsx
      • header.tsx
      • footer.tsx
    • lib
      • auth.ts
      • api.ts
    • hooks
      • use-session.ts
    • app.tsx
  • tests
    • auth.spec.ts
  • package.json
  • tsconfig.json
How the indexer sees your code

One symbol per chunk. Always.

The indexer clones your repository shallowly, parses every supported file with tree-sitter and turns each function, class and component into its own embedding. The original source code is deleted right after.

That's what makes the Locator more than a vector search: it knows who calls whom, who exports what, and which files sit next to each other.

Stop writing the same boilerplate fix twice.

Connect a repo, file an issue, let the agents draft the PR. You still ship the merge.

Start with GitHubRead the docs