PatchPilot

PatchPilot is an autonomous AI engineer that reads GitHub issues, fixes the code using a Claude agent inside a Daytona Sandbox, and automatically ships a pull request — all without human intervention.

Comment

DEMO URL: https://www.loom.com/share/6aa35908a4b94d57ab9433bbac9a016a

At the end of the demo I raised an issue to add a contrast editor to the app, here is the result: (there is a possibility the sandbox preview link might timeout, if it does, feel free to ask me to refresh it)

Before Sandbox Preview: https://3000-af71e3fe-d271-4e56-8798-4909f6ec4cb2.proxy.daytona.works/

After Sandbox Preview: https://3000-4fa9538a-7248-4c84-a039-3e86a4fc8f5a.proxy.daytona.works/

Look at the images above in the galley for screenshots of the preview links

About the Project – PatchPilot

Inspiration

Every engineering team knows the pain: a bug gets filed, set up an environment, explore the codebase, implement a fix, run tests, open a pull request… and this cycle repeats endlessly.

While AI coding tools exist, none operate as a real autonomous engineer inside a safe, isolated dev environment. We asked:

What if a GitHub issue could turn itself into a pull request?

PatchPilot was born from the idea that AI agents should work inside sandboxes just like human developers — safely, consistently, and autonomously.

What PatchPilot Does

PatchPilot turns every GitHub issue into an automated development workflow:

  1. Detects a newly opened GitHub issue
  2. Creates Daytona BEFORE & AFTER sandboxes to reproduce and fix the problem
  3. Runs a Claude-powered code agent inside the sandbox
  4. Claude analyzes the issue, inspects the repo, and modifies real files directly inside Daytona
  5. PatchPilot runs tests and validates the fix
  6. PatchPilot automatically commits changes, creates a branch, and opens a GitHub Pull Request

It behaves like a true AI-powered junior engineer who understands context, works in a real dev environment, and autonomously ships fixes.

Also, if you don't like its fix, you can just reject it.

How We Built It

1. GitHub Webhooks → Backend → Daytona

When an issue is created, GitHub triggers our backend. The backend orchestrates Daytona’s official SDK to:

  • Spin up BEFORE and AFTER sandboxes
  • Clone the repository
  • Configure the workspace
  • Provide filesystem access and command execution

2. Claude Agent Running Inside Daytona

We generate a sandbox-resident Node script that:

  • Reads issue data
  • Crawls the repository
  • Collects code context
  • Sends it to Claude for deep reasoning
  • Receives updated file contents
  • Writes changes directly into the sandbox’s repo

This means the fix is produced inside Daytona’s isolated environment.

3. Automatic PR Creation

Once the fix is applied, PatchPilot:

  • Commits changes
  • Creates a new branch
  • Pushes to GitHub
  • Opens a Pull Request

What We Learned

  • How to orchestrate multiple Daytona sandboxes programmatically
  • How to safely run AI agents inside isolated environments
  • How to structure prompts so Claude can consistently modify large codebases
  • How to automate PR creation pipelines
  • How to design agent workflows that balance autonomy with reliability

Challenges We Ran Into

1. Managing Daytona sandboxes

Creating isolated BEFORE/AFTER sandboxes, handling work directories, and streaming command output required careful orchestration.

2. Running AI code inside the sandbox

Executing a Node-based Claude agent inside Daytona meant handling:

  • dependency installation
  • command execution
  • path mapping
  • file permission issues

3. Parsing and applying AI-generated code safely

Claude’s reasoning had to be constrained so file updates were predictable and usable inside the sandbox.

4. Keeping the demo deterministic

What Makes PatchPilot Unique

  • It runs Claude inside a real sandbox, not in the backend
  • It uses full Daytona workspaces to ensure safe code execution
  • It produces actual pull requests that fix real issues
  • It treats AI as a real developer, not just a code suggestion tool
  • It’s fully autonomous — no buttons, no prompts, no babysitting

Built With

  • TypeScript – backend logic, GitHub integration, agent orchestration
  • Next.js API Routes – webhook handler & backend runtime
  • Daytona SDK (@daytonaio/sdk) – sandbox creation, filesystem access, command execution
  • Claude (Anthropic API) – code analysis and autonomous patch generation
  • Node.js – runtime for the in-sandbox agent
  • GitHub API – commit & pull request automation
  • pnpm / npm – package management inside Daytona
  • Ngrok / Cloudflare Tunnel – local webhook development

Built With

Share this project:

Updates