Potpie AI vs Sourcegraph (2026)

Breadth is met across source control, ticketing and documentation: GitHub, Linear, Jira and Confluence, each connected through CLI auth commands with credential verification. Potpie also installs its instructions and skills into four coding harnesses, Claude Code, OpenAI Codex, Cursor and OpenCode, which is an unusual second dimension of breadth. Notion, Slack and a VS Code extension are not documented on any current first-party page.

Potpie either operates as a single agent or delegates execution to specialized subagents, and customers define custom agents by role, goal, backstory and system prompt, with tasks, tools and expected outputs. Multi agent runs and a buyer configured flow are both documented.

Agentic Batch Changes runs a coordinator agent that scopes a change, routes each repository to a script or a delegated coding agent in parallel containers, publishes changesets and patches CI failures until green.

Potpie is invoked from its CLI and from inside four coding harnesses, Claude Code, OpenAI Codex, Cursor and OpenCode, where installed skills let the agent call it during a task. That is genuine multi surface coverage, but every path is developer initiated. No event trigger such as a pull request, commit or ticket event, no scheduled run and no inbound chat channel is documented, and Slack assistance and event driven documentation updates do not appear on any current first-party page.

Code Monitoring alerts agents and teams when code changes and changeset hooks let the agent react to CI results, while the web app, IDE extensions, CLI and MCP server are on demand.

The context graph is the core of the product. Potpie parses a repository into a property graph of every file, function, class, import and call relationship, layers in source history, decisions, tickets and team knowledge from GitHub, Linear, Jira and Confluence, and serves it to whichever coding agent the customer already runs. potpie resolve pulls the context an agent should read before a task, and potpie search looks up a specific file, workflow, bug, decision or convention. The vendor reports operation on codebases from roughly one million to hundreds of millions of lines.

Potpie's Context Engine includes a graph backed memory layer for entities, claims, source references and timelines. Agents propose memory through semantic mutation, the record tool saves durable project memory such as decisions, observations and validated graph facts, and resolve and search read it back, all scoped to one pot. That is a stated scope and a durable lifetime; deletion is not addressed. The memory is separate from the code graph, which is covered under knowledge grounding.

Agentic Batch Changes keeps run state across a migration, but no memory the agent writes for itself with a stated scope, lifetime or review is documented.

Spec driven development is a genuine structural gate: requirements and architecture are defined and reviewable before code is written, and it is the vendor's headline workflow. The CLI surfaces context for review through potpie resolve before a task begins, and potpie graph keeps proposals and commits as distinct operations. It stays at Partial because it is a workflow convention rather than an enforced mechanism: no approval gate, permission scoping or runtime guardrail is documented, and where a coding harness runs the task, the write path is governed by that harness.

Teams approve every Agentic Batch Changes changeset before it merges, on the code host pull request, but no vendor approval step holds the agent before it edits or publishes.

The posture rests on architecture rather than attestation: Apache 2.0 source, a local daemon, local storage and optional account features. Running the whole platform on your own machine is a real data handling property, which clears the Partial floor. It stops there because no attestation, certification, SSO, SAML, RBAC or audit surface is documented anywhere. Buyers should weigh that against the vendor's reported Fortune 500 and regulated industry customers, who normally require exactly those controls.

The diagnostic surface is real and developer oriented: potpie status checks context readiness across the daemon, graph and skills, potpie doctor runs local diagnostics including skill drift, potpie auth status verifies integration credentials, and the graph explorer makes the context itself inspectable. It stays at Partial because these report on the state of the context layer and its integrations, not on what an agent did and why. No retained per action record, audit log or run history is documented.

The Agentic Batch Changes console records each coordinator step, per-repository execution and per-changeset pull request status, as shown in a product walkthrough.

Apache 2.0 with a local first architecture is a genuine residency property. The CLI installs from PyPI, the setup wizard provisions local config, storage, a daemon and a default pot, and the graph explorer runs from that local daemon in the developer's browser, so the daemon, graph storage and explorer all run on the developer's own machine. Account backed managed features are the optional path, invoked by potpie login, rather than a requirement, and the whole platform can be self hosted.

Potpie documents named prebuilt agents, each doing its own job and callable through the API: a codebase Q&A agent, a code generation agent, a spec generation agent and a debugging agent. Alongside them, Potpie ships skills that install into Claude Code, Codex, Cursor and OpenCode.

Batch Changes specs are reusable declarative templates with published examples for cross-repository work, but there is no catalog of installable agents or packs.

Cody offers Anthropic, Google and OpenAI models that admins configure and users select per use case, plus customer-chosen endpoints on Azure OpenAI, AWS Bedrock and OpenAI-compatible gateways.

Potpie documents an API on its own server: requests carry an x-api-key header against /api/v2, and the API parses a repository, creates a conversation bound to an agent and sends messages with streaming and citations. Beside it sit the PyPI CLI, which people and agents both drive, and the Apache 2.0 source. The skills installation model adds a second, outward facing route: Potpie installs guidance that other vendors' coding agents load, so its context reaches Claude Code, Codex, Cursor and OpenCode without a separate integration.

Debugging and root cause analysis are documented uses of the context layer, and the vendor cites one customer reducing root cause analysis on a 40 million line codebase from nearly a week to 30 minutes. Spec driven development aligns tests against a plan before code is written, and the CLI exposes graph quality checks. No customer facing harness for evaluating agent behavior is exposed. The vendor open sources SWE-bench predictions, execution logs, trajectories and evaluation results and publishes research on agent evaluation data, which is substantial but vendor side research rather than a product a customer points at their own agents.

The vendor's claim that complete context cuts agent retries and cost is an efficiency argument rather than a harness, and no customer-facing evaluation or regression surface for agent behavior is documented.

Everything Potpie does runs through programmatic interfaces: a Python CLI from PyPI, a local daemon serving a graph explorer, repository parsing into a graph database, integration APIs for GitHub, Linear, Jira and Confluence, and skill files that coding harnesses read. Driving a coding harness is an especially clear case, since Potpie installs files the harness reads rather than operating its interface. No browser, screenshot or GUI capability is documented.