PatchPilot

Satyam Prakash — Tue, 27 Oct 2026 05:46:28 +0000

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 4: Ghost in the Machine

PatchPilot: An AI Agent That Investigates Code Before You Touch It

This is my submission for the Hacktoberfest Open-Source AI Challenge Week 4: Ghost in the Machine.

What I Built

PatchPilot is an AI-powered codebase investigation agent designed to understand unfamiliar repositories, trace bugs, and help developers diagnose problems before making changes.

Every codebase has its own ghosts: hidden dependencies, confusing execution paths, outdated assumptions, and bugs that are difficult to reproduce. When a developer joins an unfamiliar project or encounters an unexpected failure, the hardest part is often figuring out what is actually happening.

PatchPilot approaches this problem by investigating the codebase rather than immediately suggesting fixes.

The agent can inspect project structure, search source files, examine Git status and diffs, review branches and commit history, and inspect repository remotes. It uses these tools to gather evidence and build a clearer picture of the problem before explaining its findings.

I designed PatchPilot around a simple principle: understand first, explain with evidence, and ask for approval before changing anything.

Instead of giving an AI agent unrestricted control over a repository, PatchPilot prioritizes read-only investigation and keeps potentially risky modifications behind an explicit approval step.

The goal is to make AI-assisted debugging more transparent, controlled, and useful for real-world software development.

Demo

GitHub Repository: SatyamPrakash09/PatchPilot
Project Status: Under active development.

The repository contains the project implementation and ongoing development work.

Code

Explore the source code:

SatyamPrakash09 / PatchPilot

PatchPilot is an agentic AI coding assistant designed to explore local codebases, investigate bugs, search code and AST symbols, inspect Git repositories, and reason about fixes directly from your terminal or web interface.

🛰️ PatchPilot

PatchPilot is an agentic AI coding assistant designed to explore local codebases, investigate bugs, search code and AST symbols, inspect Git repositories, and reason about fixes directly from your terminal or web interface.

Built using LangGraph, LangChain, Ollama, and Tree-sitter, PatchPilot runs locally or cloud-connected via Ollama with zero cloud vendor lock-in.

📋 Table of Contents

🏗️ Architecture & Workflow

PatchPilot implements a progressive investigation workflow. When presented with a task or bug report, the agent navigates the codebase step-by-step:

                            User Query
                                │
                                ▼
                       ┌─────────────────┐
                       │ PatchPilot LLM  │
                       │ (ReAct Agent)   │
                       └────────┬────────┘
                                │
         ┌──────────────────────┼──────────────────────┐
         ▼                      ▼                      ▼
  📁 Filesystem           🔎 Code Search         🌳 Tree-sitter AST
  ├──

…

View on GitHub

PatchPilot is being developed as a tool-using AI agent with a focus on codebase exploration, debugging workflows, and controlled access to developer tools.

Its core investigation capabilities include:

Repository exploration: Inspecting the project structure to understand how the codebase is organized.
Code search: Finding relevant files and code paths to investigate a reported issue.
Git intelligence: Examining working-tree changes, diffs, branches, commit history, and remotes.
Evidence-driven debugging: Using repository context to investigate problems instead of relying entirely on assumptions.
Human approval: Keeping code modifications behind an approval boundary rather than allowing uncontrolled writes.

How I Built It

I am building PatchPilot with Python and local LLM inference, using Ollama to run models on my own machine.

The architecture focuses on giving the model access to specific tools instead of asking it to solve every problem from a single prompt.

The intended investigation workflow is:

Understand the request. Identify the error, unexpected behavior, or codebase question.
Explore the repository. Inspect the directory structure and locate relevant source files.
Gather evidence. Search code and use Git tools to understand the current state of the project.
Reason about the problem. Connect findings across files and identify plausible causes.
Present the investigation. Explain the evidence, likely root cause, and recommended next steps.
Keep the developer in control. Require approval before proceeding with code modifications.

I am also exploring code indexing and Tree-sitter to improve structural understanding of repositories, alongside caching and retrieval approaches that can reduce repeated investigation work.

The project is still evolving. The priority is to establish a reliable investigation loop before expanding into more autonomous code changes.

Why Does Open Innovation Matter?

PatchPilot is built around a problem developers encounter across the open-source ecosystem: understanding code that someone else wrote.

Open innovation matters here because the agent should be adaptable to different repositories, programming languages, local models, and developer workflows.

Using open-source tools and locally runnable models makes several things possible:

Local inference: Developers can experiment with AI-assisted debugging without depending entirely on a paid, hosted model API.
Greater control over code: Sensitive source code can remain on the developer's machine when the selected local setup supports fully local processing.
Model flexibility: Developers can experiment with different models through Ollama instead of being locked into a single proprietary provider.
Community-driven improvements: Contributors can inspect the implementation, report limitations, improve tools, and propose new investigation strategies.
Reproducible experimentation: Developers can test different prompts, models, retrieval strategies, and tool designs against real codebases.

A closed API could provide strong code reasoning, but PatchPilot's direction is about more than model intelligence. It is about building an inspectable, extensible, and developer-controlled workflow around that intelligence.

Open innovation gives the community the opportunity to shape how these agents investigate and interact with software.

My Agent Session

PatchPilot is still under active development, and I have not included a public DevRelay agent-session recording yet.

The GitHub repository is the best place to follow its implementation and development progress.

The Spirit of It

There is something unsettling about opening a large repository, encountering a bug, and realizing that you do not yet understand enough of the code to know where to look.

The failure might be visible, but its cause could be hidden across several files, an old commit, or an unexpected dependency.

That is the ghost in the machine.

I wanted to build an agent that does not simply invent a confident answer or immediately rewrite the code. Instead, it investigates, gathers evidence, and explains what it discovers.

PatchPilot is my attempt to make that process more systematic: an AI pair investigator that helps developers understand unfamiliar software while leaving the final decisions in human hands.

The long-term vision is an agent that can navigate complex repositories, trace failures across interconnected components, and propose well-supported fixes without sacrificing developer control.

DEV Community: Satyam Prakash