Yantra, an autonomous bug-fix agent

One-line summary: A bug reported in Slack, caught automatically by Sentry, or filed from an in-app button becomes a test-verified GitHub pull request. Yantra does the tedious ninety percent, then stops and waits for a human to approve and an authorized reviewer to merge.

--

Problem Statement

Most bugs sit in a backlog for days. Someone has to notice the failure, reproduce it, find the cause, write a fix, and prove it does not break anything else. The work is mechanical and repetitive, but handing it to an AI raises an obvious fear: you cannot let an agent ship code to production on its own. The challenge was not to make an agent that does more. It was to build one disciplined enough that a team would actually trust it near their repository.

--

Solution

Yantra is an agent that lives where developers already work. A bug enters through one of three doors: Sentry captures a crash automatically, a teammate reports it in Slack, or a user files it from an in-app button. From there the agent runs a fixed pipeline: triage the report with a cheap model, reproduce the bug against the project's real test suite, confirm a test actually fails, research the correct fix with grounded and cited sources, write the smallest safe patch, and re-run the tests.

Two guarantees are structural, not promised. Yantra never opens a pull request until the tests pass, and there is no code path where it can merge without a human. Any signed-in teammate can approve, and only an authorized reviewer role can merge to main. The human sees the whole thing happen on a live console and approves right inside Slack.

The interesting engineering was the restraint, not the automation. The line between "the agent handles it" and "a person decides" is the entire product.

--

Tech Stack

--

Key Features

The pipeline

• Triage: a cheap model decides whether the report is a real, actionable bug and how urgent it is.
• Reproduce: runs the target app's real test suite, so a failing test is a real bug, not user error.
• Verify before: a failing test confirms the bug is real before any change is made.
• Research: Exa returns a grounded, cited answer about the correct handling, so the fix is not guessed from a training cutoff.
• Fix: writes the smallest safe patch.
• Verify after: re-runs the tests. No green, no pull request.
• Open PR: a real pull request with the diff and an explanation.

The human boundary

• The write boundary: no pull request until the tests pass, and no merge without a human, enforced in the code path rather than promised.
• Role-based merge: any authenticated teammate can approve. Only an authorized reviewer can merge to main, enforced on the server.
• Approve where you work: the agent narrates its progress in Slack and the approval happens on interactive buttons there, or on the live review console.

The live console

• A generative-UI panel streams the agent's state stage by stage, with its sources, the diff, and a running model cost, so a person can watch it think instead of trusting a black box.

--

What this shows

This project was less about wiring six tools together and more about deciding what an autonomous system is allowed to do alone, then making that boundary real in the architecture. The result is a demo that reads as something a team would trust, not just a script that runs.

Code: github.com/SavvaPranay/Yantra Demo: youtu.be/bNWWKHFX4u0 Built at: AI Tinkerers "Agents, Everywhere" global hackathon with OpenAI.