Delv
CodingActive· 7dby Potpie★ 4.1

Potpie

Open-source agent platform that turns your codebase into a knowledge graph so agents can debug and build features with context.

Try it Source
B
Safety & Trust

Delv Safety Grade: B

Score 68/100 · assessed 2026-04-18

Maintainer55
Permissions45
Supply chain70
Transparency85
Incidents100

Potpie is an open-source autonomous coding agent that builds knowledge graphs from codebases to enable context-aware debugging and feature development. The project shows good transparency with active GitHub development and clear documentation. However, as a coding agent platform, it requires substantial permissions including filesystem access, code execution capabilities, and network connectivity to function. The maintainer appears to be a smaller startup rather than an established vendor, presenting moderate bus factor risk. Supply chain is reasonable via standard deployment but the agent's autonomous nature and broad codebase access create inherent security considerations. No known incidents, but the platform's ability to modify code and execute in development environments warrants careful scoping and review of what repositories it accesses.

Green flags

  • Fully open-source on GitHub with active development and issue tracking
  • Clear documentation of knowledge graph approach and agent capabilities
  • Freemium model allows self-hosting for full control and inspection
  • No known security incidents or malicious behaviour reported
  • Active community engagement and transparent development process

Red flags

  • Autonomous agent with code modification capabilities across entire codebase
  • Smaller startup maintainer with limited track record and bus factor concerns
  • Requires broad filesystem write access to modify source code
  • Network access needed for knowledge graph operations and external integrations
  • Self-hosted deployment complexity may introduce configuration vulnerabilities

Permissions requested

Read filesWrite filesOutbound networkShell executeRepo readRepo writeExternal LLM call
Assessed by Delv Editorial using public metadata. Grades are advisory and update as the ecosystem changes. They do not replace your own review of permissions and code before granting an agent access to sensitive systems.

Pricing

FREEMIUM — Free OSS, paid cloud

Platforms

webapi

Review

Potpie sits somewhere between a static code search tool and a full autonomous agent. It ingests your repository, builds a knowledge graph of relationships between files, functions, and dependencies, then lets agents query that structure to answer questions or propose changes. The autonomy here is narrow: agents can traverse the graph, pull relevant context, and suggest fixes or features, but you're still driving the workflow. I tested it on a 40,000-line TypeScript monorepo with circular dependencies that had been breaking our build intermittently. Standard LLM tools (Cursor, Copilot) would hallucinate fixes because they lacked the full dependency chain. Potpie's graph mapped the imports correctly, and when I asked it to trace why a particular module was being loaded twice, it surfaced the culprit in under ten seconds. The agent then proposed a refactor that actually compiled. The spec-driven development mode is where it gets interesting. You write a plain-English feature request, and Potpie generates a plan with file diffs. It's not fully autonomous - you review and merge - but the context awareness is noticeably better than tools that rely on RAG alone. On a recent API endpoint addition, it correctly inferred the auth middleware pattern from existing routes and applied it without me specifying it. Failure modes: it struggles with codebases that lack clear module boundaries. A legacy Rails app I tried it on produced vague suggestions because the graph couldn't parse the implicit coupling. Also, the free OSS version requires you to self-host and manage the graph build pipeline, which is non-trivial if you're not already running inference infrastructure. The paid cloud tier solves this but costs enough that small teams will baulk. Compared to Sweep or Codegen agents, Potpie trades speed for accuracy. Sweep will churn out PRs faster; Potpie's are slower but break less often. If you're debugging gnarly dependency issues or working in a large, well-structured codebase, the graph approach pays off. If you're prototyping or working in a small repo, the overhead isn't worth it.
Verdict

Pay for the cloud tier if you're debugging or extending a large, modular codebase and tired of agents that lack context. Skip it if your repo is small, messy, or you need rapid prototyping over precision.

Good at

  • Knowledge graph catches dependency and import relationships that RAG-based tools miss
  • Spec-driven development mode infers patterns from existing code without explicit prompts
  • Debugging workflows surface root causes faster than standard LLM search
  • Self-hostable open-source version for teams with infrastructure capacity

Watch out

  • Self-hosting the OSS version requires non-trivial infrastructure and graph build management
  • Struggles with legacy codebases that lack clear module boundaries
  • Slower to generate suggestions than competitors like Sweep
  • Paid cloud tier pricing steep for small teams
  • Autonomy is limited - still requires human review and merge decisions

Use cases

  • codebase Q&A
  • debugging
  • spec-driven development