Pythagora

From open-source GPT Pilot to a VS Code extension that builds full-stack apps. Honestly reviewed.

TL;DR

• What it is: An AI coding agent (VS Code extension) that uses 14 specialized AI sub-agents to plan, write, debug, and deploy full-stack web apps. Originally launched as the open-source GPT Pilot project [1][4].
• Who it’s for: Technical founders and developers who want to ship internal tools or small apps faster without hiring a full-stack team. Not a no-code tool — you still live inside VS Code [4].
• The catch: The original open-source GitHub repo (gpt-pilot) is explicitly abandoned. The current Pythagora product is a commercial SaaS. The license shows as NOASSERTION, meaning it’s not a standard open-source license [4].
• Cost: Free tier available. Pro/Premium plans start at $49/month. Cursor, the closest SaaS competitor, starts at $20/month [website FAQ].
• Key strength: Multi-agent architecture that doesn’t just autocomplete — it writes an implementation plan, generates code, runs it, catches errors, and iterates, with human checkpoints along the way [1][4].
• Key weakness: The repo hasn’t been updated in 5+ months, the open-source foundation has been quietly dropped, and the product is mid-pivot — the website still has lorem ipsum placeholder text in the hero section as of this review [website scrape].

---

What is Pythagora

Pythagora started life as GPT Pilot, an open-source research project asking a direct question: how much of an actual software project can an LLM build end-to-end, not just autocomplete? The answer they arrived at, after six months of building and publishing their learnings, was roughly 95% — with the remaining 5% requiring a human who understands context, constraints, and intent [1].

The GitHub repo at github.com/pythagora-io/gpt-pilot accumulated 33,807 stars on the strength of that idea. It was a real agentic coding system, not an autocomplete wrapper. You gave it an app description, it wrote an implementation plan, asked clarifying questions, generated code file by file, ran the app, and iterated on failures.

Then Pythagora quietly pivoted. The README now reads: “This repo is not being maintained anymore. Visit Pythagora.ai for more info.” The stars stayed, the GitHub link stayed on their website, but the open-source project is done [README][4].

What replaced it is a VS Code extension (and Cursor plugin) that does roughly the same thing but as a managed commercial product. According to the website FAQ, behind the scenes it runs “14 specialized agents that handle everything from planning and writing code to reviewing, testing, debugging, and deploying full-stack web apps” using “top-tier language models from OpenAI, Anthropic, and others” [website FAQ]. You describe what you want to build; Pythagora does the building, stopping to ask when it hits decisions that require human input.

The tech stack is fixed: React for the frontend, Node.js for the backend. Python is listed as “on the way” [website FAQ]. Data dashboards support MongoDB, PostgreSQL, MySQL, and spreadsheets [website]. The company is YC-backed and SF-based, which explains both the ambition of the pitch and the classic Y Combinator move of pivoting from open-source traction toward a commercial product [README].

As an alternative, OpenAlternative lists Pythagora as an open-source alternative to Lovable, Cursor, Kiro, and Windsurf — 17 SaaS products in total [4]. That’s a lot of comparisons to invite.

---

Why people choose it

The original GPT Pilot blog post [1] is the best primary source we have for why the product resonated. The team’s central insight was that LLMs fail at long-horizon tasks not because they lack knowledge, but because they lack sustained focus. Their solution was to break software development into orchestrated sub-tasks — each agent handles a narrow slice, hands off to the next, and the human stays in the loop at decision points.

That architecture produced results the team published openly. Four examples built with early GPT Pilot: a Prompt Lab app (2 days), a database analyzer (2 days), Code Whisperer (7 hours), Star History (6 hours) [1]. These aren’t toy projects — they’re usable internal tools.

Among the AI coding agents that exist right now, Pythagora sits in a specific niche: it’s closer to Lovable or Bolt.new (describe → get a working app) than it is to Cursor or GitHub Copilot (write code faster with AI assistance). The difference matters. Cursor assumes you know what you’re building and helps you build it. Pythagora assumes you know what you want and handles how to build it.

OpenAlternative’s rankings place Pythagora consistently in the top tier of open-source alternatives to Cursor, Windsurf, and GitHub Copilot [2][3][5], though those rankings were written when the open-source version was still alive. That context is now outdated.

What people cite as the actual draw:

• Multi-agent planning loop. Not just “generate this function” but “plan the whole feature, implement it, test it, debug when it fails, and stop to ask me the right questions.” [1][4]
• You own the code. The FAQ is explicit: “You do. Everything you build with Pythagora is yours. Every file, every line of code.” This isn’t always the case with AI app builders [website FAQ].
• Real debugging, not just generation. The website describes a backend debugging view where you can “track task flows, inspect dependencies, and watch issues resolve in real time” [website].

---

Features

Based on the website and FAQ — the README is no longer current [website][4]:

App building:

• Describe an app in natural language; Pythagora generates an implementation plan before writing a line of code [1][4]
• 14 specialized AI agents covering planning, coding, review, testing, debugging, and deployment [website FAQ]
• Frontend: React. Backend: Node.js. Python backend support listed as forthcoming [website FAQ]
• One-click deployment with preview and production environments kept in sync [website]

Debugging and iteration:

• Automatic breakpoints [4]
• Task flow inspection — visual view of what agents are doing and where failures occur [website]
• “Detects failed jobs, suggests fixes, and re-runs tasks until they pass” [website]
• Human-in-the-loop at key decision points — Pythagora asks specific questions rather than guessing [1]

Data and dashboards:

• Generate live dashboards from database connections [website]
• Supports MongoDB, PostgreSQL, MySQL, spreadsheets [website]

Team features:

• RBAC (role-based access control) [website]
• Workflow automations [website]
• Centralized team access [website]

What’s missing or unclear:

• No self-hosted community edition anymore — that was GPT Pilot, which is now archived [README]
• No documented REST API or extension framework mentioned in current materials
• “Infinite Integrations” is listed as a feature heading on the website with no further detail [website scrape]

---

Pricing: SaaS vs self-hosted math

Pythagora pricing (as of this review):

• Free: Available (limits not specified on the website)
• Pro/Premium: Starting at $49/month [website FAQ]
• Enterprise: Custom pricing, contact sales [website FAQ]

Exact tier limits (task count, seat count, deployment limits) are not specified in any source available for this review. The website FAQ says “If you need more power, we offer Pro and Premium plans” without defining what “more power” means concretely. This is a notable gap — buying a tool you can’t size is a risk.

Competitor pricing:

• Cursor: $20/month (Hobby), $40/month (Pro), $40/user/month (Business)
• GitHub Copilot: $10/month individual, $19/user/month Business
• Lovable: ~$20/month entry tier
• Windsurf: Free tier, paid plans available

At $49/month, Pythagora is 2.5x Cursor’s Hobby plan and 5x GitHub Copilot’s individual plan. The pitch is that you’re not paying for autocomplete — you’re paying for an agent that builds the entire feature. If that holds up in practice, the math could favor Pythagora for solo founders who’d otherwise spend a week on a feature. If it doesn’t hold up, you’ve paid $49 for a worse autocomplete tool.

The self-hosted angle is gone. GPT Pilot, the open-source version, let you bring your own API keys (OpenAI, Anthropic, Groq) and run everything locally. Your API costs were your only cost. That option no longer exists in the current Pythagora product. The website mentions “works on your dedicated cloud instance or fully locally” but provides no documentation or community edition for this [website]. It reads more like a privacy reassurance than a deployment option.

---

Deployment reality check

For the VS Code extension: install it from the marketplace, authenticate with Pythagora, and start building. No server to manage. No Docker compose file. No VPS. This is both simpler and more constraining than a self-hosted tool — simpler because you skip infrastructure entirely, constraining because you’re fully dependent on Pythagora’s uptime and pricing.

The original GPT Pilot had a real setup process: clone the repo, create a Python virtual environment, install dependencies, set up a config file with your LLM API keys, optionally configure PostgreSQL, and run the CLI or install the VS Code extension [README]. For technical users this was ~30 minutes. That path is gone.

What to watch for:

• The project hasn’t been committed to in 5+ months [4]. OpenAlternative flags this explicitly with a warning: “This project hasn’t been updated in 5 months and might not be actively maintained anymore.” [4] For a tool that builds production apps, that staleness matters.
• The Pythagora.ai website, as of the scrape date, still contains lorem ipsum placeholder text in the hero section — not a confidence-inspiring signal for a product targeting “startups to global teams” [website scrape].
• The website claims “10+”, “35%”, and “60%” as social proof numbers with no labels attached to them — the page rendering appears to have broken the context for these figures [website scrape]. Data not available for what they represent.
• Tech stack is locked to React + Node.js. If your backend is Python, Rails, or Go, you’re not in the target audience right now [website FAQ].

---

Pros and Cons

Pros

• Multi-agent architecture does real planning. Not just code generation — Pythagora breaks down requirements, writes a plan, implements piece by piece, and iterates on failures. This is meaningfully different from autocomplete [1][4].
• You own the code. Unlike some AI app builders, the output is your codebase, not a locked platform [website FAQ].
• Pair programming model with checkpoints. The original team’s research showed LLMs perform better when asked one specific question at a time rather than open-ended prompts. Pythagora is built around that insight — it stops and asks specific questions rather than hallucinating forward [1].
• Built-in debugging visibility. Task flow inspection and auto-retry on failures is a real differentiator from tools that just generate and abandon [website].
• YC-backed with real traction. 33,807 GitHub stars is genuine validation, not artificial inflation [4].
• Works inside your existing IDE. VS Code extension means you don’t switch to a new tool — it integrates into your existing workflow [4].

Cons

• Open-source version is dead. The 33,807 GitHub stars belong to a project that’s explicitly no longer maintained. The current product is proprietary SaaS [README][4].
• License is NOASSERTION. Not MIT, not Apache, not any standard open-source license. You don’t have source code rights on the current product [4].
• Pricing opacity. $49/month starting price with no public explanation of what the tiers include is a red flag when evaluating budget [website FAQ].
• No Python backend support yet. React + Node.js is the only supported stack. This eliminates a large portion of the technical founder market [website FAQ].
• Maintenance signal is bad. Five months without a commit on the main repo, lorem ipsum still on the live website, broken stat rendering — these are signs of a team that’s either heads-down on something not yet shipped, or struggling [4][website scrape].
• At $49/month, it’s more expensive than the main competition. Cursor Pro is $40/month with broader IDE support and a proven track record. The case for paying more needs to be made more clearly than the current website does [website FAQ].
• No documented API or integration surface. You can’t programmatically trigger builds, integrate Pythagora into CI/CD, or build on top of it [4].

---

Who should use this / who shouldn’t

Use Pythagora if:

• You’re a technical founder or developer who needs to ship internal tools fast and React + Node.js fits your stack.
• You want an AI agent that plans before it builds — not just autocomplete but actual feature planning and implementation.
• You tried Lovable or Bolt.new and found them too disconnected from your actual development workflow.
• You’re comfortable paying $49/month for a tool that saves you multiple days of development on each feature.

Skip it if:

• You’re looking for the open-source, self-hosted, bring-your-own-API-keys version. That’s GPT Pilot, and it’s archived [README].
• Your backend is anything other than Node.js right now. Python support is “on the way” — that’s not a shipping date [website FAQ].
• You need pricing transparency before committing. The current website doesn’t give you enough information to size your costs.
• You’re a non-technical founder who wants to build apps without touching VS Code. This is a developer tool, not a no-code platform [4].

Choose Cursor instead if:

• You want a mature, actively-developed AI coding assistant with proven reliability, broader language support, and $20/month clarity.

Choose Lovable or Bolt.new instead if:

• You want to build web apps through a browser interface without installing a VS Code extension.

Consider waiting if:

• You’re seriously interested but concerned about the maintenance signals. A 6-month check-in to see if the product has shipped meaningful updates would be reasonable given the current state.

---

Alternatives worth considering

Cursor — The current market benchmark for AI coding assistants. Not an app builder like Pythagora, but a coding accelerator. More mature, actively developed, $20–40/month, no tech stack lock-in [2][5].

GitHub Copilot — The safe enterprise choice. Tightly integrated with GitHub, $10/month, broad language support. Less autonomous than Pythagora — it helps you write code, not write the app for you [5].

Cline — Open-source, genuinely MIT-licensed, works in VS Code, integrates with Claude and OpenAI, and has MCP support. Closer to Pythagora’s agent model than GitHub Copilot. More transparent about what it’s doing [2][5].

Lovable — Browser-based AI app builder targeting non-technical users. Easier entry point than Pythagora if you’re not comfortable in VS Code [4].

Bolt.new — Similar browser-based app generation. 16,319 GitHub stars, active development [4].

Aider — Terminal-based, open-source, works with your existing git repo. Narrower than Pythagora but honest about what it is and actively maintained [2][3].

Dyad — Newer entrant, 20,122 stars, last commit 1 day ago as of this review, builds full-stack AI apps locally with no vendor lock-in [4]. Worth watching as a self-hostable alternative.

---

Bottom line

Pythagora’s underlying idea is sound and the team published six months of real research proving it works: multi-agent orchestration with human checkpoints produces better AI-generated apps than single-shot code generation. The GPT Pilot GitHub project demonstrated that concretely and earned 33,000+ stars doing it.

The problem is that project is gone. What’s left is a commercial VS Code extension with pricing that starts at $49/month, a tech stack locked to React + Node.js, a maintenance record that’s been quiet for five months, and a website that still has lorem ipsum in the hero copy. That’s not a damning verdict — YC companies pivot, products get rebuilt, websites get fixed — but it is a product you should evaluate at the current moment, not on the strength of the original GPT Pilot reputation.

If you’re a developer who wants an AI agent that plans and builds features end-to-end rather than just autocompleting code, Pythagora’s architecture is the right architecture. The question is whether the current execution and pricing justify $49/month over Cursor at $20/month or Cline at $0. On the evidence available today, that’s a harder case to make than it was when GPT Pilot was shipping weekly.

---

Sources

1. Ivis Buric, Pythagora Blog — “What we learned in 6 months of working on a CodeGen dev tool GPT Pilot” (February 19, 2024). https://blog.pythagora.ai/gpt-pilot-what-did-we-learn-in-6-months-of-working-on-a-codegen-pair-programmer/

2. Piotr Kulpinski, OpenAlternative — “10+ Best Open Source Cursor Alternatives in 2026” (April 16, 2026). https://openalternative.co/alternatives/cursor

3. Piotr Kulpinski, OpenAlternative — “10+ Best Open Source Windsurf Alternatives in 2026” (April 16, 2026). https://openalternative.co/alternatives/windsurf

4. OpenAlternative — “Pythagora: Open Source Alternative to Lovable, Cursor and Kiro” (auto-fetched April 2026). https://openalternative.co/pythagora

5. Piotr Kulpinski, OpenAlternative — “10+ Best Open Source GitHub Copilot Alternatives in 2026” (April 16, 2026). https://openalternative.co/alternatives/github-copilot

Primary sources:

• GitHub repository (archived): https://github.com/pythagora-io/gpt-pilot (33,807 stars)
• Official website: https://www.pythagora.ai
• VS Code Marketplace extension: https://marketplace.visualstudio.com/items?itemName=PythagoraTechnologies.pythagora-vs-code