From 2ef377414adbb3d3e22def892f99a28339e574aa Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Tue, 14 Jul 2026 17:47:12 +0000 Subject: [PATCH 1/3] docs: add /compare pages for agent orchestration competitors Add a Docusaurus compare section with Treq vs Superset, Conductor, Emdash, Claude Squad, Graphite (for AI teams), and Orca. Wire navbar and footer links so the pages publish at treq.dev/compare/... Co-authored-by: Ziinc --- web/compare/index.mdx | 23 +++++ web/compare/treq-vs-claude-squad.mdx | 90 ++++++++++++++++++ web/compare/treq-vs-conductor.mdx | 90 ++++++++++++++++++ web/compare/treq-vs-emdash.mdx | 90 ++++++++++++++++++ web/compare/treq-vs-graphite-for-ai-teams.mdx | 91 ++++++++++++++++++ web/compare/treq-vs-orca.mdx | 95 +++++++++++++++++++ web/compare/treq-vs-superset.mdx | 91 ++++++++++++++++++ web/docusaurus.config.ts | 21 ++++ web/sidebarsCompare.ts | 19 ++++ 9 files changed, 610 insertions(+) create mode 100644 web/compare/index.mdx create mode 100644 web/compare/treq-vs-claude-squad.mdx create mode 100644 web/compare/treq-vs-conductor.mdx create mode 100644 web/compare/treq-vs-emdash.mdx create mode 100644 web/compare/treq-vs-graphite-for-ai-teams.mdx create mode 100644 web/compare/treq-vs-orca.mdx create mode 100644 web/compare/treq-vs-superset.mdx create mode 100644 web/sidebarsCompare.ts diff --git a/web/compare/index.mdx b/web/compare/index.mdx new file mode 100644 index 00000000..d3d9a247 --- /dev/null +++ b/web/compare/index.mdx @@ -0,0 +1,23 @@ +--- +sidebar_position: 1 +description: Compare Treq with agent orchestration tools and stacked PR platforms for AI coding teams. +--- + +# Compare + +_How Treq differs from other agent tools and stacked PR platforms._ + +Treq is a desktop AI workspace manager. It helps you run coding agents in parallel on your machine. The focus is human review, stacked workspaces, and rebasing when AI branches drift. + +These pages put Treq next to products people often evaluate with it. Each page covers features, pricing, and the trade-offs that matter when you pick a tool. + +| Comparison | Best when you care about | +| --- | --- | +| [Treq vs Superset](./treq-vs-superset) | Broad agent control, team packaging, and review-focused workflows | +| [Treq vs Conductor](./treq-vs-conductor) | Mac-native agent workspaces versus stacked review and rebase workflows | +| [Treq vs Emdash](./treq-vs-emdash) | Cross-platform open-source breadth versus review and stack depth | +| [Treq vs Claude Squad](./treq-vs-claude-squad) | Terminal tools versus a review-first desktop workspace | +| [Treq vs Graphite for AI teams](./treq-vs-graphite-for-ai-teams) | Stacked PR tooling when agents write most of the code | +| [Treq vs Orca](./treq-vs-orca) | Full IDE-like surface versus branch hygiene and review quality | + +New to the category? Start with [agent orchestration](/learn/concepts/ai-engineering/agent-orchestration), [git worktrees](/learn/concepts/git/git-worktrees), and [stacked PRs](/learn/concepts/git/stacked-prs). diff --git a/web/compare/treq-vs-claude-squad.mdx b/web/compare/treq-vs-claude-squad.mdx new file mode 100644 index 00000000..d9bf1d5e --- /dev/null +++ b/web/compare/treq-vs-claude-squad.mdx @@ -0,0 +1,90 @@ +--- +sidebar_position: 5 +description: Compare Treq and Claude Squad for multi-agent isolation, from terminal multiplexing to desktop review workflows. +--- + +# Treq vs Claude Squad + +_Same isolation idea, different control surfaces: desktop review versus terminal multiplexing._ + +Treq and Claude Squad both start from git worktree isolation and parallel agent sessions. They serve different preferences for how much UI you want between you and the agents. + +Treq is a desktop AI workspace manager with PR-style review, stacked workspaces, and automatic rebasing. Claude Squad is a terminal-native manager that uses tmux sessions and git worktrees for people who want minimal abstraction. + +## At a Glance + +| | Treq | Claude Squad | +| --- | --- | --- | +| Positioning | AI workspace manager for busy developers | Terminal-native manager for multiple AI terminal agents | +| Control surface | Desktop app | Terminal UI over tmux | +| Isolation model | Jujutsu workspaces over a colocated Git repo | Git worktrees plus tmux sessions | +| Review surface | PR-style diffs and line comments | Basic or TUI-oriented review before push | +| Stacked changes | Core workflow | Not emphasized publicly | +| Auto-rebase | Core workflow | No public auto-rebase story | +| Remote or cloud workspaces | Not public on the site today | No | +| License | Apache 2.0 | AGPL-3.0 | +| Pricing | Free and open source | Free and open source | +| Distribution | GitHub releases and docs | Homebrew and GitHub | + +## What Each Product Does + +**Treq** gives each agent workspace its own working copy, terminal, and review surface. You inspect diffs, leave comments, and send feedback back to the agent. Dependent workspaces can form a stack. Rebases and conflicts are product features, not a manual side process. + +**Claude Squad** keeps you in the terminal. It manages multiple AI agent sessions through tmux, isolates work with git worktrees, supports background work, and expects review before push. The appeal is low abstraction and fast install for power users who already live in shell workflows. + +Both tools reject the idea that several agents should share one dirty working tree. Both keep the human responsible for what gets pushed. + +## Feature Comparison + +| Feature | Treq | Claude Squad | +| --- | --- | --- | +| Local-first | Yes | Yes | +| Parallel agent sessions | Yes | Yes | +| Git or VCS isolation | Yes | Yes | +| Desktop review UI | Yes | No, terminal-oriented | +| Comments sent back to the agent | Yes | Manual, outside a PR-style UI | +| Stacked PR or stacked workspace support | Yes | Not emphasized publicly | +| Auto-rebase and conflict handling | Yes | No | +| Background agent work | Yes, per-workspace terminals | Yes | +| Enterprise or remote packaging | Not public on the site today | No | +| License | Apache 2.0 | AGPL-3.0 | + +## Where They Differ + +The main difference is the control surface. Claude Squad assumes you want tmux, a terminal UI, and as little desktop chrome as possible. Treq assumes review quality and stack maintenance deserve a dedicated interface. + +That leads to different failure modes. With Claude Squad, the cost shows up when review, comment routing, and stack rebases remain manual. With Treq, the cost shows up when you wanted a thinner tool and the desktop environment is more than you need. + +Licensing also differs. Apache 2.0 and `AGPL-3.0` create different obligations if you embed or redistribute the tool inside a larger system. For many individual developers that distinction never appears. For companies packaging internal platforms, it can. + +## Pricing and Licensing + +Both are free and open source. + +Treq uses Apache 2.0. Claude Squad uses `AGPL-3.0`. Install paths differ too. Treq ships through GitHub releases and product docs. Claude Squad ships through Homebrew and the project repository. + +Model provider costs are separate for both. + +## Who Should Choose Which + +Choose **Treq** if you: + +- Want a desktop diff and comment workflow that feeds the next agent turn. +- Need stacked workspaces and automatic rebasing. +- Prefer Apache 2.0 for company or platform use. +- Are building a review-heavy process around AI-generated pull requests. + +Choose **Claude Squad** if you: + +- Prefer terminal-native tools and already use tmux heavily. +- Want the lightest possible multi-agent control layer. +- Do not need stacked PR UI, remote workspaces, or enterprise packaging. +- Are comfortable handling review and rebase mechanics yourself. + +## Next Steps + +- [Treq vs Emdash](./treq-vs-emdash): open-source ADE breadth versus review depth. +- [Treq vs Conductor](./treq-vs-conductor): another desktop orchestrator with a different product bet. +- [Parallel development workflow](/learn/workflows/git/parallel-development): how isolated directories support concurrent work. +- [Creating terminal sessions](/docs/tutorials/creating-terminal-sessions): terminals inside Treq workspaces. +- [Installation](/docs/getting-started/installation): install Treq and open a repository. \ No newline at end of file diff --git a/web/compare/treq-vs-conductor.mdx b/web/compare/treq-vs-conductor.mdx new file mode 100644 index 00000000..f3eeb83a --- /dev/null +++ b/web/compare/treq-vs-conductor.mdx @@ -0,0 +1,90 @@ +--- +sidebar_position: 3 +description: Compare Treq and Conductor for parallel coding agents on the desktop, with a focus on review, stacks, and platform scope. +--- + +# Treq vs Conductor + +_Both run agents in isolated workspaces. Treq bets on stacked review. Conductor bets on a polished Mac workflow._ + +Treq and Conductor solve the same first problem. Give every coding agent its own workspace, branch, files, terminal, and review path. After that shared base, the products diverge. + +Treq focuses on human-in-the-loop diffs, stacked workspaces, and automatic rebasing. Conductor focuses on a Mac-native interface for running Claude, Codex, Cursor, and OpenCode agents as a team. + +## At a Glance + +| | Treq | Conductor | +| --- | --- | --- | +| Positioning | AI workspace manager, open-source Graphite alternative | Human interface to AI organizations on your Mac | +| Platform | Desktop app, currently marketed for macOS | Mac-first desktop app | +| Isolation model | Jujutsu workspaces over a colocated Git repo | Per-task workspace, branch, files, terminal, and diff | +| Review surface | PR-style diffs with comments sent back to the agent | Diff and review path per task | +| Stacked changes | Core workflow | Not emphasized publicly | +| Auto-rebase | Core workflow | Not emphasized publicly | +| Agent support | Claude, Codex, and Cursor shown today | Claude, Codex, Cursor, and OpenCode | +| Cloud | Not public on the site today | Cloud early access | +| Open source | Apache 2.0 | No public OSS repo surfaced | +| Pricing | Free and open source | Download-first, public self-serve pricing not disclosed | + +## What Each Product Does + +**Treq** manages parallel workspaces for coding agents and keeps the merge path under human control. You inspect changes, leave line comments, and send that feedback back into the agent loop. Dependent workspaces can target each other as a stack. When a lower layer moves, Treq rebases higher layers and surfaces conflicts. + +**Conductor** is a Mac app for running a team of coding agents. Each task gets an isolated workspace with its own branch, files, terminal, diff, and review path. Public materials highlight Linear integration, multiple run scripts, and a download-first path that uses your existing Claude login. The product story centers on a polished human interface for AI teams. Stacked PR mechanics are not the public focus. + +Both products assume agents need isolation. Both assume developers still need a review step before merge. Neither is a general AI code editor. Both sit above the agents as a control layer. + +## Feature Comparison + +| Feature | Treq | Conductor | +| --- | --- | --- | +| Local-first desktop app | Yes | Yes, Mac-first | +| Parallel agent sessions | Yes | Yes | +| Workspace isolation | Yes | Yes | +| Review and diff UI | Strong emphasis | Yes | +| Comments sent back to the agent | Yes | Review path exists, agent-loop comments are not the public center | +| Stacked PR or stacked workspace support | Yes | Not emphasized publicly | +| Auto-rebase and conflict handling | Yes | Not emphasized publicly | +| Issue tracker integration | Not public on the site today | Linear integration | +| Cloud workspaces | Not public on the site today | Cloud early access | +| Open source | Apache 2.0 | Closed source in public materials | + +## Where They Differ + +Conductor's public strength is commercial and product momentum. It presents a clear Mac-native workflow, strong growth signals, and team-facing motion. If your team already lives in Claude, Codex, Cursor, or OpenCode on macOS, that focus can reduce setup cost. + +Treq's public strength is a narrower workflow. Stacked workspaces, review comments that return to the agent, and auto-rebase target a later failure mode. After parallel generation succeeds, branches go stale. Stacks drift. Review quality becomes the bottleneck. + +Platform scope also differs. Conductor's Mac-first story narrows the audience and sharpens the experience. Treq's open-source packaging makes inspection and contribution part of the adoption path. Cloud workspaces exist as early access in Conductor's public materials. They are not a public Treq offering today. + +## Pricing and Licensing + +Treq is free and open source under Apache 2.0. There is no public paid plan today. + +Conductor's site is download-first. Launch copy has described free use with an existing Claude login. Team and commercial terms also exist. Public self-serve pricing is not a clear bottom-funnel page in the same way as products with published Pro tiers. + +Model and agent usage fees remain separate in both cases. + +## Who Should Choose Which + +Choose **Treq** if you: + +- Need stacked workspaces and automatic rebasing for dependent AI changes. +- Want PR-style review comments to drive the next agent turn. +- Prefer Apache 2.0 open source and local review data. +- Care more about branch hygiene and safe shipping than about Mac-native polish alone. + +Choose **Conductor** if you: + +- Want a polished Mac app centered on Claude, Codex, Cursor, and OpenCode. +- Prefer a download-first product with Linear integration and cloud early access. +- Care more about team orchestration narrative and commercial packaging than stacked PR tooling. +- Are less concerned about open-source licensing for the orchestrator itself. + +## Next Steps + +- [Treq vs Superset](./treq-vs-superset): breadth and packaging versus review-focused orchestration. +- [Treq vs Orca](./treq-vs-orca): ADE surface area versus stacked review depth. +- [Changes and reviews](/docs/concepts/changes-and-reviews): how Treq turns diffs into agent feedback. +- [Workspaces](/docs/concepts/workspaces): how stacked workspaces and rebases work. +- [Installation](/docs/getting-started/installation): install Treq and open a repository. \ No newline at end of file diff --git a/web/compare/treq-vs-emdash.mdx b/web/compare/treq-vs-emdash.mdx new file mode 100644 index 00000000..8df72499 --- /dev/null +++ b/web/compare/treq-vs-emdash.mdx @@ -0,0 +1,90 @@ +--- +sidebar_position: 4 +description: Compare Treq and Emdash as open-source agent development environments, focusing on review, stacks, and provider breadth. +--- + +# Treq vs Emdash + +_Two Apache-licensed desktop apps for parallel coding agents, with different centers of gravity._ + +Treq and Emdash are both open-source desktop products for running multiple coding agents. Both isolate work per task. Both expect you to review results before shipping. The comparison turns on depth versus breadth. + +Treq focuses on review loops, stacked workspaces, and automatic rebasing. Emdash focuses on provider coverage, prompts and skills, remote work, and a wider environment with browser and editor features. + +## At a Glance + +| | Treq | Emdash | +| --- | --- | --- | +| Positioning | AI workspace manager, open-source Graphite alternative | Open-source agentic development environment | +| Isolation model | Jujutsu workspaces over a colocated Git repo | Parallel agent tasks with workspace isolation | +| Review surface | PR-style diffs, comments sent back to the agent | Review surfaces inside a broader ADE | +| Stacked changes | Core workflow | Not emphasized publicly | +| Auto-rebase | Core workflow | Not emphasized publicly | +| Provider support | Claude, Codex, and Cursor shown today | 34 supported agent CLIs in public materials | +| Remote work | Not public on the site today | SSH remote work, cloud workspaces, enterprise on-your-infra | +| License | Apache 2.0 | Apache 2.0 | +| Pricing | Free and open source | Free desktop app, enterprise and cloud contact motion | + +## What Each Product Does + +**Treq** keeps the developer in the merge path. Agents work in isolated workspaces. You review diffs, annotate lines, and send comments back for planning or editing. Stacked workspaces model dependent changes. When a lower workspace updates, dependents can rebase automatically and surface conflicts. + +**Emdash** presents itself as an environment for multiple coding agents. Public materials stress parallel tasks and a large set of supported agent CLIs. They also cover prompts, skills, MCP tools, an in-app browser, file editing, and issue handoff. SSH remote work and cloud or team deployment options are part of the same story. The product aims to cover the environment around agents, not only the local review loop. + +Both are Apache 2.0. That makes licensing a weaker point of difference here than in comparisons with source-available or closed products. + +## Feature Comparison + +| Feature | Treq | Emdash | +| --- | --- | --- | +| Local-first desktop app | Yes | Yes | +| Parallel agent sessions | Yes | Yes | +| Workspace isolation | Yes | Yes | +| Review and diff UI | Strong emphasis | Yes | +| Comments sent back to the agent | Yes | Broader ADE review, less public emphasis on stacked review loops | +| Stacked PR or stacked workspace support | Yes | Not emphasized publicly | +| Auto-rebase and conflict handling | Yes | Not emphasized publicly | +| Broad provider support | Focused set today | 34 supported agent CLIs | +| SSH or remote workspaces | Not public on the site today | Yes | +| Cloud and enterprise packaging | Not public on the site today | Yes | +| Open source | Apache 2.0 | Apache 2.0 | + +## Where They Differ + +Emdash wins on surface area. If you need many providers, remote execution, cloud workspaces, or team deployment options, its public roadmap and packaging are broader. That is the right fit when the control plane must meet agents wherever they already run. + +Treq wins on a narrower workflow claim. Stacked changes and human-in-the-loop review are the product, not an accessory. That is the right fit when agent output volume is high. The costly failures then are stale stacks, weak reviews, and unsafe merges. + +Domain and brand continuity also differ in practice. Emdash has used more than one public domain. Some indexes still show legacy content from an older product. Treq's brand collisions come from unrelated "treq" entities, not from leftover product pages on the same domain. Neither issue decides the technical choice. Both affect how people find the products. + +## Pricing and Licensing + +Both desktop apps are free and open source under Apache 2.0. + +Emdash adds enterprise and cloud packaging through a contact-sales style motion. Treq does not publish a paid plan today. + +Agent and model costs remain outside either license. + +## Who Should Choose Which + +Choose **Treq** if you: + +- Want stacked workspaces and automatic rebasing as default behavior. +- Care most about PR-style review that feeds the next agent turn. +- Prefer a focused local workflow over a broad ADE feature set. +- Are evaluating open-source options specifically for safe shipping of AI-generated code. + +Choose **Emdash** if you: + +- Need wide CLI provider coverage today. +- Want SSH remote work, cloud workspaces, or on-your-infra enterprise options. +- Prefer an ADE that includes browser, editor, prompts, skills, and MCP tooling in one surface. +- Care more about environment breadth than stacked PR specialization. + +## Next Steps + +- [Treq vs Orca](./treq-vs-orca): another open-source ADE comparison with a different momentum profile. +- [Treq vs Superset](./treq-vs-superset): packaging and breadth versus review focus. +- [Agent orchestration](/learn/concepts/ai-engineering/agent-orchestration): why isolation and review matter once agents run in parallel. +- [Code review workflow](/docs/tutorials/code-review-workflow): Treq's review loop in practice. +- [Installation](/docs/getting-started/installation): install Treq and open a repository. \ No newline at end of file diff --git a/web/compare/treq-vs-graphite-for-ai-teams.mdx b/web/compare/treq-vs-graphite-for-ai-teams.mdx new file mode 100644 index 00000000..80c6b64d --- /dev/null +++ b/web/compare/treq-vs-graphite-for-ai-teams.mdx @@ -0,0 +1,91 @@ +--- +sidebar_position: 6 +description: Compare Treq and Graphite for AI coding teams that need stacked pull requests, review discipline, and agent-friendly workflows. +--- + +# Treq vs Graphite for AI Teams + +_Graphite popularized stacked PRs for humans. Treq applies stacked development to agent-generated work._ + +Graphite and Treq are not the same category of product, but AI teams often evaluate them together. Graphite is a stacked pull request and code review platform. Treq is a local AI workspace manager. It uses stacked workspaces, human-in-the-loop review, and automatic rebasing around coding agents. + +The comparison matters because agent throughput changes where the pain shows up. When people wrote most of the code, stack tools focused on review batching and merge order. When agents write most of the code, you also need isolation. You need comment routing back into agent sessions. You need ongoing rebase hygiene. + +## At a Glance + +| | Treq | Graphite | +| --- | --- | --- | +| Product type | Local AI workspace manager | Stacked PR and code review platform | +| Primary surface | Desktop app on your machine | Web app and CLI around GitHub pull requests | +| Stack model | Stacked workspaces with dependent targets | Stacked pull requests | +| Agent orchestration | Parallel agent workspaces and terminals | Not an agent orchestrator | +| Review model | Local PR-style diffs, comments sent back to the agent | Hosted pull request review workflows | +| Auto-rebase | Built into workspace stack updates | Stack restack workflows in the Graphite product | +| Privacy model | Local-only review data on your machine | Cloud-hosted collaboration around GitHub | +| Open source | Apache 2.0 | Commercial product | +| Best fit | AI teams generating many dependent local changes | Teams standardizing stacked PR review on GitHub | + +## What Each Product Does + +**Treq** creates isolated workspaces for coding agents, shows diffs for review, and turns comments into the next agent prompt. Workspaces can target other workspaces to form a stack. When a lower layer moves, Treq rebases dependents and surfaces conflicts. The product is local-first and designed for the loop between generation and inspection. + +**Graphite** helps teams create, review, restack, and merge stacked pull requests. It sits on top of GitHub's pull request model and optimizes the social and process layer of code review: smaller diffs, clearer dependencies, and better merge sequencing. It is not a desktop environment for launching Claude, Codex, or Cursor agents in parallel worktrees. + +Teams looking for a "Graphite alternative" for AI work usually want one of two things. Some want open-source stacked PR mechanics without Graphite's commercial surface. Others want stacked development that starts earlier, at the agent workspace layer, before a pull request exists. Treq is aimed at the second need, and can still participate in GitHub-centered review after you push. + +## Feature Comparison + +| Feature | Treq | Graphite | +| --- | --- | --- | +| Stacked changes | Yes, as stacked workspaces | Yes, as stacked pull requests | +| Restack or rebase support | Yes | Yes | +| Parallel coding agent workspaces | Yes | No | +| Local diff review before push | Yes | Review is centered on hosted PRs | +| Comments sent back to an agent | Yes | Comments stay in the PR review system unless you bridge them yourself | +| GitHub PR collaboration | After push, through normal Git tooling | Native product focus | +| Local-only privacy for review drafts | Yes | Cloud collaboration model | +| Open source | Apache 2.0 | No | + +## Where They Differ + +Graphite assumes the unit of work is a pull request that teammates review together. That remains valuable when humans are the primary reviewers and GitHub is the system of record. + +Treq assumes the unit of work often starts as an agent workspace. The first reviewer may be the developer who launched the agent. Comments need to return to the agent quickly. Stacks need to stay current while several agents continue working. The pull request can come later. + +This is why Treq calls itself an open-source Graphite alternative in public materials without claiming feature parity with Graphite's hosted review platform. The shared idea is stacked development. The implementation point is different: workspace orchestration versus PR collaboration. + +If your team already has a strong Graphite workflow, Treq can still help on the generation side. Agents work in isolated stacks locally, you review there, then you push into whatever PR process you already trust. If your team has no agent orchestration layer yet, starting with Graphite alone leaves the parallel generation problem unsolved. + +## Pricing and Licensing + +Treq is free and open source under Apache 2.0. There is no public paid plan today. + +Graphite is a commercial product with its own packaging and pricing. Evaluate current Graphite plans on Graphite's site when cost is part of the decision. + +Treq does not replace GitHub, CI, or your team's final review policy. It changes where the first review and rebase loop happens. + +## Who Should Choose Which + +Choose **Treq** if you: + +- Run coding agents in parallel and need local isolation before a PR exists. +- Want stacked workspaces with automatic rebasing while agents keep working. +- Need review comments to go back into the agent loop. +- Want an open-source, local-first workflow for AI-generated changes. + +Choose **Graphite** if you: + +- Already standardize on stacked GitHub pull requests for human teams. +- Need hosted collaboration features around PR review and merge queues. +- Are solving review process on GitHub more than local agent orchestration. +- Do not need a desktop environment for launching and supervising coding agents. + +Many AI-native teams will eventually want both layers. Use local agent orchestration with stack hygiene, then a hosted PR process for team review. The mistake is treating them as interchangeable. + +## Next Steps + +- [Stacked PRs](/learn/concepts/git/stacked-prs): the dependency model behind stacked development. +- [Stacked PR workflow](/learn/workflows/git/stacked-pr): how to split and restack dependent changes. +- [Treq vs Superset](./treq-vs-superset): compare Treq with a direct agent orchestrator. +- [Workspaces](/docs/concepts/workspaces): how Treq models stacks and rebases. +- [Installation](/docs/getting-started/installation): install Treq and open a repository. \ No newline at end of file diff --git a/web/compare/treq-vs-orca.mdx b/web/compare/treq-vs-orca.mdx new file mode 100644 index 00000000..d5ff6a32 --- /dev/null +++ b/web/compare/treq-vs-orca.mdx @@ -0,0 +1,95 @@ +--- +sidebar_position: 7 +description: Compare Treq and Orca for agent development environments, from ADE surface area to stacked review and rebase workflows. +--- + +# Treq vs Orca + +_Both isolate agents in worktrees. Orca expands the full environment. Treq deepens review and stack hygiene._ + +Treq and Orca are open-source products for agent development. Each gives coding agents isolated workspaces. Each gives you a place to watch the work. The real difference is scope. + +Orca presents a broad environment. It supports any CLI agent, built-in editing, browser and design surfaces, mobile companion support, and enterprise packaging. Treq presents a narrower workflow. It focuses on human-in-the-loop review, stacked workspaces, and automatic rebasing for AI-generated branches. + +## At a Glance + +| | Treq | Orca | +| --- | --- | --- | +| Positioning | AI workspace manager, open-source Graphite alternative | Agent development environment, worktree IDE for coding agents | +| Isolation model | Jujutsu workspaces over a colocated Git repo | Worktree per task, with terminal and browser tab | +| Review surface | PR-style diffs, comments sent back to the agent | Diff and Git tracking inside a broader ADE | +| Stacked changes | Core workflow | Not emphasized publicly | +| Auto-rebase | Core workflow | Not emphasized publicly | +| Provider support | Claude, Codex, and Cursor shown today | Any CLI agent | +| Extra surfaces | Desktop review and terminals | File editor, browser or design mode, mobile companion | +| Remote work | Not public on the site today | SSH worktrees and enterprise packaging | +| License | Apache 2.0 | MIT | +| Pricing | Free and open source | Free and open source, enterprise contact motion | + +## What Each Product Does + +**Treq** manages parallel agent workspaces and keeps merge quality under human control. You review changes, leave comments, and send that feedback back to the agent. Dependent workspaces form stacks. When lower layers move, Treq rebases dependents and shows conflicts. + +**Orca** aims to be the place where agent work happens. Public materials stress per-task worktrees, terminals, browser tabs, a built-in file editor, and Git tracking. They also cover mobile support, automation copy, and paid team plans. The product story is a full environment for developers who already run many agents. + +Both products accept that parallel agents need isolation. Both are open source. Both face pressure from vendor-owned agent apps that absorb these features over time. + +## Feature Comparison + +| Feature | Treq | Orca | +| --- | --- | --- | +| Local-first desktop app | Yes | Yes | +| Parallel agent sessions | Yes | Yes | +| Worktree or workspace isolation | Yes | Yes | +| Review and diff UI | Strong emphasis | Yes | +| Comments sent back to the agent | Yes | Broader ADE review, less public emphasis on stacked review loops | +| Stacked PR or stacked workspace support | Yes | Not emphasized publicly | +| Auto-rebase and conflict handling | Yes | Not emphasized publicly | +| Built-in file editor | Not the product center | Yes | +| Browser or design mode | Not public on the site today | Yes | +| Mobile companion | No | Yes | +| SSH worktrees | Not public on the site today | Yes | +| Enterprise packaging | Not public on the site today | Yes | +| Open source | Apache 2.0 | MIT | + +## Where They Differ + +Orca's public momentum comes from breadth and speed. High GitHub traction, frequent releases, and a wide feature set make it look like a full environment for agent work. That is useful when you want one product for editing, browsing, mobile access, and remote worktrees. + +Treq's public bet is a narrower workflow. If parallel worktrees become common, the hard problems left are review quality, dependent changes, and keeping AI branches current. Treq puts those problems at the center. + +That creates a clear trade-off. Choose Orca when you want a full environment more than a specific merge workflow. Choose Treq when weak reviews, drifting stacks, and conflict-heavy AI branches are the costly failures. + +Brand search is noisy for both. "Orca" collides with many unrelated products. "Treq" collides with an older Python package and other entities. Specific workflow pages matter more than bare brand queries. + +## Pricing and Licensing + +Both desktop products are free and open source. Treq uses Apache 2.0. Orca uses MIT. + +Orca also publishes enterprise packaging with a contact motion. Treq does not publish a paid plan today. + +Model and agent fees remain separate. + +## Who Should Choose Which + +Choose **Treq** if you: + +- Want stacked workspaces and automatic rebasing as core behavior. +- Care most about PR-style review that returns comments to the agent. +- Prefer a focused local workflow over a full ADE feature set. +- Want safe shipping of AI-generated code as the main goal. + +Choose **Orca** if you: + +- Want a broad ADE with editor, browser, automation, and mobile surfaces. +- Need SSH worktrees or enterprise packaging today. +- Prefer any-CLI-agent flexibility as the primary buying criterion. +- Care more about environment completeness than stacked PR specialization. + +## Next Steps + +- [Treq vs Emdash](./treq-vs-emdash): another open-source ADE comparison. +- [Treq vs Superset](./treq-vs-superset): packaging breadth versus review focus. +- [Treq vs Graphite for AI teams](./treq-vs-graphite-for-ai-teams): why stacked workflows matter for agent output. +- [Human-in-the-loop development](/learn/concepts/ai-engineering/human-in-the-loop-development): the review model behind Treq. +- [Installation](/docs/getting-started/installation): install Treq and open a repository. \ No newline at end of file diff --git a/web/compare/treq-vs-superset.mdx b/web/compare/treq-vs-superset.mdx new file mode 100644 index 00000000..547d5b9c --- /dev/null +++ b/web/compare/treq-vs-superset.mdx @@ -0,0 +1,91 @@ +--- +sidebar_position: 2 +description: Compare Treq and Superset for parallel coding agents, review workflows, stacked changes, and packaging. +--- + +# Treq vs Superset + +_Two local-first agent orchestrators with different bets: review and stacks, or breadth and packaging._ + +Treq and Superset both run coding agents in isolated workspaces. Both give you a place to review the result. They sit in the same product category. The useful difference is what each product focuses on after the agents start writing code. + +Treq is built around human-in-the-loop review, stacked workspaces, and automatic rebasing of AI-generated branches. Superset is built around running many CLI agents in parallel. It also packages the product for individuals, teams, and enterprise buyers. + +## At a Glance + +| | Treq | Superset | +| --- | --- | --- | +| Positioning | AI workspace manager, open-source Graphite alternative | Code editor for AI agents, software-factory platform | +| Isolation model | Jujutsu workspaces over a colocated Git repo | Git worktrees per task | +| Review surface | PR-style diffs, line comments sent back to the agent | Diff and file review inside the app | +| Stacked changes | Core workflow | Not emphasized publicly | +| Auto-rebase | Core workflow | Not emphasized publicly | +| Provider model | Claude, Codex, and Cursor shown today | Very broad CLI agent support | +| Remote or cloud workspaces | Not public on the site today | Remote workspaces and enterprise packaging | +| License | Apache 2.0 | Source-available under ELv2 | +| Pricing | Free and open source | Free tier, Pro, and Enterprise | + +## What Each Product Does + +**Treq** is a desktop app for managing parallel agent workspaces. Each workspace has its own working copy, terminal, and line of history. You review diffs like a familiar pull request, leave comments, and send that feedback back to the agent. When a lower workspace in a stack moves, Treq can rebase dependents and surface conflicts for resolution. + +**Superset** is a local-first desktop workspace for many coding agents. It launches CLI agents in isolated Git worktrees and surrounds them with chat, browser, review, and automation surfaces. Its public story emphasizes parallel scale, integrations with tools like GitHub, Linear, and Slack, and a path from free use into team and enterprise packaging. + +Both products assume the same basic problem: one shared checkout is a poor place for several agents to work at once. Both solve isolation with per-task working directories. + +## Feature Comparison + +| Feature | Treq | Superset | +| --- | --- | --- | +| Local-first desktop app | Yes | Yes | +| Parallel agent sessions | Yes | Yes, with an explicit 100+ agent ambition | +| Workspace isolation | Yes | Yes | +| Review and diff UI | Strong emphasis | Yes | +| Comments sent back to the agent | Yes | Review surfaces exist, agent-loop feedback is not the center of the public pitch | +| Stacked PR or stacked workspace support | Yes | Not emphasized publicly | +| Auto-rebase and conflict handling | Yes | Not emphasized publicly | +| Automations and scheduling | Not public on the site today | Yes | +| Remote or cloud workspaces | Not public on the site today | Yes | +| Open source | Apache 2.0 | Source-available under ELv2 | + +## Where They Differ + +The shared category is parallel agents in isolated workspaces. The split is what happens next. + +Treq treats review quality as the product. Diff comments, stacked dependencies, and rebase hygiene are first-class. That matters when agents produce a lot of code. The bottleneck then moves from writing code to inspecting it and merging safely. + +Superset treats breadth as the product. Provider coverage, automations, remote workspaces, and team packaging are more visible in its public materials. That matters when you want one control plane for many agents and team workflows beyond a single developer's review loop. + +If "run many agents" becomes common, these differences remain. Breadth and packaging are easy for rivals to copy in messaging. Stacked review and automatic rebase are harder to fake without shipping the workflow. + +## Pricing and Licensing + +Treq is free and open source under Apache 2.0. There is no public paid plan today. + +Superset offers a free tier, Pro pricing around $15 per user per month when billed yearly, and custom Enterprise pricing. Its desktop code is source-available under Elastic License 2.0, which is not the same as Apache-style open source. + +In both cases you still pay the underlying model providers for Claude, Codex, or any other agent usage. + +## Who Should Choose Which + +Choose **Treq** if you: + +- Care more about reviewing and shipping AI-generated code than about launching the largest number of agents. +- Want stacked workspaces and automatic rebasing as part of the default workflow. +- Prefer Apache 2.0 open source and a local-only review loop. +- Are looking for a Graphite-like stacked workflow built for coding agents. + +Choose **Superset** if you: + +- Need broad CLI agent support and frequent provider switching. +- Want remote workspaces, automations, and team or enterprise packaging today. +- Prefer a product that already has pricing pages, compare content, and self-serve team plans. +- Care more about orchestration breadth than stacked PR discipline. + +## Next Steps + +- [Treq vs Conductor](./treq-vs-conductor): Mac-native agent workspaces versus stacked review workflows. +- [Treq vs Graphite for AI teams](./treq-vs-graphite-for-ai-teams): why stacked PR tooling matters once agents write most of the code. +- [Human-in-the-loop review workflow](/learn/workflows/git/human-in-the-loop-review): how review comments become the next agent prompt. +- [Stacked PR workflow](/learn/workflows/git/stacked-pr): how dependent branches stay reviewable. +- [Installation](/docs/getting-started/installation): install Treq and open a repository. \ No newline at end of file diff --git a/web/docusaurus.config.ts b/web/docusaurus.config.ts index 42c26f17..ed45a873 100644 --- a/web/docusaurus.config.ts +++ b/web/docusaurus.config.ts @@ -23,6 +23,16 @@ const config: Config = { editUrl: 'https://github.com/Ziinc/treq/tree/main/web/', }, ], + [ + '@docusaurus/plugin-content-docs', + { + id: 'compare', + path: 'compare', + routeBasePath: 'compare', + sidebarPath: './sidebarsCompare.ts', + editUrl: 'https://github.com/Ziinc/treq/tree/main/web/', + }, + ], function chunkSplittingPlugin() { return { name: 'chunk-splitting-plugin', @@ -177,6 +187,13 @@ const config: Config = { position: 'left', label: 'Docs', }, + { + type: 'docSidebar', + sidebarId: 'compareSidebar', + docsPluginId: 'compare', + position: 'left', + label: 'Compare', + }, { to: '/tools', label: 'Tools', @@ -237,6 +254,10 @@ const config: Config = { label: 'Security and Privacy', to: '/docs/security-and-privacy', }, + { + label: 'Compare', + to: '/compare', + }, ], }, { diff --git a/web/sidebarsCompare.ts b/web/sidebarsCompare.ts new file mode 100644 index 00000000..81ca0693 --- /dev/null +++ b/web/sidebarsCompare.ts @@ -0,0 +1,19 @@ +import type {SidebarsConfig} from '@docusaurus/plugin-content-docs'; + +const sidebars: SidebarsConfig = { + compareSidebar: [ + { + type: 'doc', + id: 'index', + label: 'Overview', + }, + 'treq-vs-superset', + 'treq-vs-conductor', + 'treq-vs-emdash', + 'treq-vs-claude-squad', + 'treq-vs-graphite-for-ai-teams', + 'treq-vs-orca', + ], +}; + +export default sidebars; From 69560b89488103e6ec2ec106f975397e9153792b Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Wed, 15 Jul 2026 18:21:40 +0000 Subject: [PATCH 2/3] docs: align compare pages with Stacking ADE positioning Co-authored-by: Ziinc --- web/compare/index.mdx | 6 ++--- web/compare/treq-vs-claude-squad.mdx | 6 ++--- web/compare/treq-vs-conductor.mdx | 10 ++++----- web/compare/treq-vs-emdash.mdx | 22 +++++++++---------- web/compare/treq-vs-graphite-for-ai-teams.mdx | 8 +++---- web/compare/treq-vs-orca.mdx | 12 +++++----- web/compare/treq-vs-superset.mdx | 22 +++++++++---------- 7 files changed, 43 insertions(+), 43 deletions(-) diff --git a/web/compare/index.mdx b/web/compare/index.mdx index d3d9a247..a3728bb4 100644 --- a/web/compare/index.mdx +++ b/web/compare/index.mdx @@ -1,13 +1,13 @@ --- sidebar_position: 1 -description: Compare Treq with agent orchestration tools and stacked PR platforms for AI coding teams. +description: Compare Treq's Stacking ADE with agent development environments, terminal tools, and stacked PR platforms. --- # Compare -_How Treq differs from other agent tools and stacked PR platforms._ +_How Treq's Stacking ADE differs from other agent tools and stacked PR platforms._ -Treq is a desktop AI workspace manager. It helps you run coding agents in parallel on your machine. The focus is human review, stacked workspaces, and rebasing when AI branches drift. +Treq is a desktop **Stacking Agent Development Environment (ADE)**. It gives each coding agent an isolated workspace, then connects dependent workspaces into a stack. Review and automatic rebasing keep each layer ready to ship. These pages put Treq next to products people often evaluate with it. Each page covers features, pricing, and the trade-offs that matter when you pick a tool. diff --git a/web/compare/treq-vs-claude-squad.mdx b/web/compare/treq-vs-claude-squad.mdx index d9bf1d5e..154d5755 100644 --- a/web/compare/treq-vs-claude-squad.mdx +++ b/web/compare/treq-vs-claude-squad.mdx @@ -9,13 +9,13 @@ _Same isolation idea, different control surfaces: desktop review versus terminal Treq and Claude Squad both start from git worktree isolation and parallel agent sessions. They serve different preferences for how much UI you want between you and the agents. -Treq is a desktop AI workspace manager with PR-style review, stacked workspaces, and automatic rebasing. Claude Squad is a terminal-native manager that uses tmux sessions and git worktrees for people who want minimal abstraction. +Treq is a desktop Stacking ADE with PR-style review and automatic rebasing across dependent workspaces. Claude Squad is a terminal-native manager that uses tmux sessions and git worktrees for people who want minimal abstraction. ## At a Glance | | Treq | Claude Squad | | --- | --- | --- | -| Positioning | AI workspace manager for busy developers | Terminal-native manager for multiple AI terminal agents | +| Positioning | Stacking ADE for dependent agent work | Terminal-native manager for multiple AI terminal agents | | Control surface | Desktop app | Terminal UI over tmux | | Isolation model | Jujutsu workspaces over a colocated Git repo | Git worktrees plus tmux sessions | | Review surface | PR-style diffs and line comments | Basic or TUI-oriented review before push | @@ -28,7 +28,7 @@ Treq is a desktop AI workspace manager with PR-style review, stacked workspaces, ## What Each Product Does -**Treq** gives each agent workspace its own working copy, terminal, and review surface. You inspect diffs, leave comments, and send feedback back to the agent. Dependent workspaces can form a stack. Rebases and conflicts are product features, not a manual side process. +**Treq** gives each agent workspace its own working copy, terminal, and review surface. A target relationship connects dependent workspaces into a stack. You inspect each layer, send comments back to the agent, and let Treq rebase higher layers when their base changes. **Claude Squad** keeps you in the terminal. It manages multiple AI agent sessions through tmux, isolates work with git worktrees, supports background work, and expects review before push. The appeal is low abstraction and fast install for power users who already live in shell workflows. diff --git a/web/compare/treq-vs-conductor.mdx b/web/compare/treq-vs-conductor.mdx index f3eeb83a..0b9657b9 100644 --- a/web/compare/treq-vs-conductor.mdx +++ b/web/compare/treq-vs-conductor.mdx @@ -7,15 +7,15 @@ description: Compare Treq and Conductor for parallel coding agents on the deskto _Both run agents in isolated workspaces. Treq bets on stacked review. Conductor bets on a polished Mac workflow._ -Treq and Conductor solve the same first problem. Give every coding agent its own workspace, branch, files, terminal, and review path. After that shared base, the products diverge. +Treq and Conductor solve the same first problem. Each coding agent gets its own workspace, branch, files, terminal, and review path. Their models diverge when tasks depend on one another. -Treq focuses on human-in-the-loop diffs, stacked workspaces, and automatic rebasing. Conductor focuses on a Mac-native interface for running Claude, Codex, Cursor, and OpenCode agents as a team. +Treq is a Stacking ADE built around dependent workspaces, human review, and automatic rebasing. Conductor focuses on a Mac-native interface for running Claude, Codex, Cursor, and OpenCode agents as a team. ## At a Glance | | Treq | Conductor | | --- | --- | --- | -| Positioning | AI workspace manager, open-source Graphite alternative | Human interface to AI organizations on your Mac | +| Positioning | Stacking ADE, open-source Graphite alternative | Human interface to AI organizations on your Mac | | Platform | Desktop app, currently marketed for macOS | Mac-first desktop app | | Isolation model | Jujutsu workspaces over a colocated Git repo | Per-task workspace, branch, files, terminal, and diff | | Review surface | PR-style diffs with comments sent back to the agent | Diff and review path per task | @@ -53,7 +53,7 @@ Both products assume agents need isolation. Both assume developers still need a Conductor's public strength is commercial and product momentum. It presents a clear Mac-native workflow, strong growth signals, and team-facing motion. If your team already lives in Claude, Codex, Cursor, or OpenCode on macOS, that focus can reduce setup cost. -Treq's public strength is a narrower workflow. Stacked workspaces, review comments that return to the agent, and auto-rebase target a later failure mode. After parallel generation succeeds, branches go stale. Stacks drift. Review quality becomes the bottleneck. +Treq's workflow starts with the stack. A workspace can target another workspace, so dependent changes retain their merge order while agents work. Review comments return to the agent, and automatic rebasing keeps higher layers current when a lower layer changes. Platform scope also differs. Conductor's Mac-first story narrows the audience and sharpens the experience. Treq's open-source packaging makes inspection and contribution part of the adoption path. Cloud workspaces exist as early access in Conductor's public materials. They are not a public Treq offering today. @@ -84,7 +84,7 @@ Choose **Conductor** if you: ## Next Steps - [Treq vs Superset](./treq-vs-superset): breadth and packaging versus review-focused orchestration. -- [Treq vs Orca](./treq-vs-orca): ADE surface area versus stacked review depth. +- [Treq vs Orca](./treq-vs-orca): broad ADE features versus a stack-native workflow. - [Changes and reviews](/docs/concepts/changes-and-reviews): how Treq turns diffs into agent feedback. - [Workspaces](/docs/concepts/workspaces): how stacked workspaces and rebases work. - [Installation](/docs/getting-started/installation): install Treq and open a repository. \ No newline at end of file diff --git a/web/compare/treq-vs-emdash.mdx b/web/compare/treq-vs-emdash.mdx index 8df72499..3f37f10f 100644 --- a/web/compare/treq-vs-emdash.mdx +++ b/web/compare/treq-vs-emdash.mdx @@ -5,17 +5,17 @@ description: Compare Treq and Emdash as open-source agent development environmen # Treq vs Emdash -_Two Apache-licensed desktop apps for parallel coding agents, with different centers of gravity._ +_Two Apache-licensed desktop ADEs with different models for multi-agent work._ -Treq and Emdash are both open-source desktop products for running multiple coding agents. Both isolate work per task. Both expect you to review results before shipping. The comparison turns on depth versus breadth. +Treq and Emdash are open-source desktop ADEs for running many coding agents. Both isolate work per task and let you review the result. Their models differ when tasks depend on one another. -Treq focuses on review loops, stacked workspaces, and automatic rebasing. Emdash focuses on provider coverage, prompts and skills, remote work, and a wider environment with browser and editor features. +Treq is a Stacking ADE built around linked workspaces and auto-rebase. Emdash supports more providers, remote work, prompts, skills, and built-in browser and editor tools. ## At a Glance | | Treq | Emdash | | --- | --- | --- | -| Positioning | AI workspace manager, open-source Graphite alternative | Open-source agentic development environment | +| Positioning | Stacking ADE, open-source Graphite alternative | Open-source agentic development environment | | Isolation model | Jujutsu workspaces over a colocated Git repo | Parallel agent tasks with workspace isolation | | Review surface | PR-style diffs, comments sent back to the agent | Review surfaces inside a broader ADE | | Stacked changes | Core workflow | Not emphasized publicly | @@ -27,11 +27,11 @@ Treq focuses on review loops, stacked workspaces, and automatic rebasing. Emdash ## What Each Product Does -**Treq** keeps the developer in the merge path. Agents work in isolated workspaces. You review diffs, annotate lines, and send comments back for planning or editing. Stacked workspaces model dependent changes. When a lower workspace updates, dependents can rebase automatically and surface conflicts. +**Treq** keeps you in the merge path. Agents work in isolated workspaces. You review diffs, mark lines, and send comments back for planning or editing. A stack links workspaces that depend on each other. When a lower workspace updates, Treq rebases the layers above it and shows conflicts. -**Emdash** presents itself as an environment for multiple coding agents. Public materials stress parallel tasks and a large set of supported agent CLIs. They also cover prompts, skills, MCP tools, an in-app browser, file editing, and issue handoff. SSH remote work and cloud or team deployment options are part of the same story. The product aims to cover the environment around agents, not only the local review loop. +**Emdash** is an environment for multiple coding agents. Its public materials feature parallel tasks and broad CLI support. Prompts, skills, MCP tools, an in-app browser, file editing, and issue handoff expand that environment. Emdash also supports SSH remote work and cloud deployment. -Both are Apache 2.0. That makes licensing a weaker point of difference here than in comparisons with source-available or closed products. +Both use Apache 2.0, so licensing does not separate them. ## Feature Comparison @@ -51,11 +51,11 @@ Both are Apache 2.0. That makes licensing a weaker point of difference here than ## Where They Differ -Emdash wins on surface area. If you need many providers, remote execution, cloud workspaces, or team deployment options, its public roadmap and packaging are broader. That is the right fit when the control plane must meet agents wherever they already run. +Emdash covers more of the environment around each agent. It supports many providers, remote execution, cloud workspaces, and team deployment. This model fits teams whose agents run across different tools and machines. -Treq wins on a narrower workflow claim. Stacked changes and human-in-the-loop review are the product, not an accessory. That is the right fit when agent output volume is high. The costly failures then are stale stacks, weak reviews, and unsafe merges. +Treq makes the stack the main unit of work. Each workspace holds one reviewable layer and names the layer below it. Auto-rebase keeps higher workspaces current as lower workspaces change. -Domain and brand continuity also differ in practice. Emdash has used more than one public domain. Some indexes still show legacy content from an older product. Treq's brand collisions come from unrelated "treq" entities, not from leftover product pages on the same domain. Neither issue decides the technical choice. Both affect how people find the products. +Emdash has used more than one public domain. Some search indexes still show pages from an older product. Treq shares its name with unrelated products, including a Python package. These brand issues affect how people find each tool, but they do not change the product choice. ## Pricing and Licensing @@ -71,7 +71,7 @@ Choose **Treq** if you: - Want stacked workspaces and automatic rebasing as default behavior. - Care most about PR-style review that feeds the next agent turn. -- Prefer a focused local workflow over a broad ADE feature set. +- Need an ADE where dependent agent tasks form a managed stack. - Are evaluating open-source options specifically for safe shipping of AI-generated code. Choose **Emdash** if you: diff --git a/web/compare/treq-vs-graphite-for-ai-teams.mdx b/web/compare/treq-vs-graphite-for-ai-teams.mdx index 80c6b64d..17672c03 100644 --- a/web/compare/treq-vs-graphite-for-ai-teams.mdx +++ b/web/compare/treq-vs-graphite-for-ai-teams.mdx @@ -7,7 +7,7 @@ description: Compare Treq and Graphite for AI coding teams that need stacked pul _Graphite popularized stacked PRs for humans. Treq applies stacked development to agent-generated work._ -Graphite and Treq are not the same category of product, but AI teams often evaluate them together. Graphite is a stacked pull request and code review platform. Treq is a local AI workspace manager. It uses stacked workspaces, human-in-the-loop review, and automatic rebasing around coding agents. +Graphite and Treq operate at different parts of the development workflow, but AI teams often evaluate them together. Graphite is a stacked pull request and code review platform. Treq is a local Stacking ADE that manages dependent agent workspaces before you open a pull request. The comparison matters because agent throughput changes where the pain shows up. When people wrote most of the code, stack tools focused on review batching and merge order. When agents write most of the code, you also need isolation. You need comment routing back into agent sessions. You need ongoing rebase hygiene. @@ -15,7 +15,7 @@ The comparison matters because agent throughput changes where the pain shows up. | | Treq | Graphite | | --- | --- | --- | -| Product type | Local AI workspace manager | Stacked PR and code review platform | +| Product type | Local Stacking ADE | Stacked PR and code review platform | | Primary surface | Desktop app on your machine | Web app and CLI around GitHub pull requests | | Stack model | Stacked workspaces with dependent targets | Stacked pull requests | | Agent orchestration | Parallel agent workspaces and terminals | Not an agent orchestrator | @@ -27,7 +27,7 @@ The comparison matters because agent throughput changes where the pain shows up. ## What Each Product Does -**Treq** creates isolated workspaces for coding agents, shows diffs for review, and turns comments into the next agent prompt. Workspaces can target other workspaces to form a stack. When a lower layer moves, Treq rebases dependents and surfaces conflicts. The product is local-first and designed for the loop between generation and inspection. +**Treq** creates isolated workspaces for coding agents, shows diffs for review, and turns comments into the next agent prompt. Workspaces target other workspaces to form a stack before any pull request exists. When a lower layer moves, Treq rebases dependents and shows conflicts. **Graphite** helps teams create, review, restack, and merge stacked pull requests. It sits on top of GitHub's pull request model and optimizes the social and process layer of code review: smaller diffs, clearer dependencies, and better merge sequencing. It is not a desktop environment for launching Claude, Codex, or Cursor agents in parallel worktrees. @@ -52,7 +52,7 @@ Graphite assumes the unit of work is a pull request that teammates review togeth Treq assumes the unit of work often starts as an agent workspace. The first reviewer may be the developer who launched the agent. Comments need to return to the agent quickly. Stacks need to stay current while several agents continue working. The pull request can come later. -This is why Treq calls itself an open-source Graphite alternative in public materials without claiming feature parity with Graphite's hosted review platform. The shared idea is stacked development. The implementation point is different: workspace orchestration versus PR collaboration. +This is why Treq calls itself an open-source Graphite alternative without claiming feature parity with Graphite's hosted review platform. Both products use stacked development. Treq applies the stack to local agent workspaces, while Graphite applies it to hosted pull requests. If your team already has a strong Graphite workflow, Treq can still help on the generation side. Agents work in isolated stacks locally, you review there, then you push into whatever PR process you already trust. If your team has no agent orchestration layer yet, starting with Graphite alone leaves the parallel generation problem unsolved. diff --git a/web/compare/treq-vs-orca.mdx b/web/compare/treq-vs-orca.mdx index d5ff6a32..f5e6750e 100644 --- a/web/compare/treq-vs-orca.mdx +++ b/web/compare/treq-vs-orca.mdx @@ -1,21 +1,21 @@ --- sidebar_position: 7 -description: Compare Treq and Orca for agent development environments, from ADE surface area to stacked review and rebase workflows. +description: Compare Treq's stack-native workflow with Orca's broader agent development environment. --- # Treq vs Orca _Both isolate agents in worktrees. Orca expands the full environment. Treq deepens review and stack hygiene._ -Treq and Orca are open-source products for agent development. Each gives coding agents isolated workspaces. Each gives you a place to watch the work. The real difference is scope. +Treq and Orca are open-source ADEs. Each gives coding agents isolated workspaces and a place to watch the work. Their workflow models differ when tasks depend on one another. -Orca presents a broad environment. It supports any CLI agent, built-in editing, browser and design surfaces, mobile companion support, and enterprise packaging. Treq presents a narrower workflow. It focuses on human-in-the-loop review, stacked workspaces, and automatic rebasing for AI-generated branches. +Orca presents a broad environment with support for any CLI agent, built-in editing, browser and design surfaces, mobile access, and enterprise packaging. Treq is a Stacking ADE. It connects dependent agent workspaces, reviews each layer, and rebases the stack as lower layers change. ## At a Glance | | Treq | Orca | | --- | --- | --- | -| Positioning | AI workspace manager, open-source Graphite alternative | Agent development environment, worktree IDE for coding agents | +| Positioning | Stacking ADE, open-source Graphite alternative | Agent development environment, worktree IDE for coding agents | | Isolation model | Jujutsu workspaces over a colocated Git repo | Worktree per task, with terminal and browser tab | | Review surface | PR-style diffs, comments sent back to the agent | Diff and Git tracking inside a broader ADE | | Stacked changes | Core workflow | Not emphasized publicly | @@ -56,7 +56,7 @@ Both products accept that parallel agents need isolation. Both are open source. Orca's public momentum comes from breadth and speed. High GitHub traction, frequent releases, and a wide feature set make it look like a full environment for agent work. That is useful when you want one product for editing, browsing, mobile access, and remote worktrees. -Treq's public bet is a narrower workflow. If parallel worktrees become common, the hard problems left are review quality, dependent changes, and keeping AI branches current. Treq puts those problems at the center. +Treq uses the stack as its primary workflow. Each workspace represents one reviewable layer and records which lower workspace it targets. Automatic rebasing keeps the dependency chain current while agents continue working. That creates a clear trade-off. Choose Orca when you want a full environment more than a specific merge workflow. Choose Treq when weak reviews, drifting stacks, and conflict-heavy AI branches are the costly failures. @@ -76,7 +76,7 @@ Choose **Treq** if you: - Want stacked workspaces and automatic rebasing as core behavior. - Care most about PR-style review that returns comments to the agent. -- Prefer a focused local workflow over a full ADE feature set. +- Need an ADE where dependent agent tasks form a managed stack. - Want safe shipping of AI-generated code as the main goal. Choose **Orca** if you: diff --git a/web/compare/treq-vs-superset.mdx b/web/compare/treq-vs-superset.mdx index 547d5b9c..ceba9d04 100644 --- a/web/compare/treq-vs-superset.mdx +++ b/web/compare/treq-vs-superset.mdx @@ -5,17 +5,17 @@ description: Compare Treq and Superset for parallel coding agents, review workfl # Treq vs Superset -_Two local-first agent orchestrators with different bets: review and stacks, or breadth and packaging._ +_Two local-first ADEs for different workflows: stacked changes or broad agent control._ -Treq and Superset both run coding agents in isolated workspaces. Both give you a place to review the result. They sit in the same product category. The useful difference is what each product focuses on after the agents start writing code. +Treq and Superset both run coding agents in isolated workspaces and give you a place to review the result. They sit in the same product category, but the workflow changes after the agents start writing code. -Treq is built around human-in-the-loop review, stacked workspaces, and automatic rebasing of AI-generated branches. Superset is built around running many CLI agents in parallel. It also packages the product for individuals, teams, and enterprise buyers. +Treq is built around human review, stacked workspaces, and auto-rebase for AI branches. Superset is built around running many CLI agents in parallel. It also sells paid plans for teams. ## At a Glance | | Treq | Superset | | --- | --- | --- | -| Positioning | AI workspace manager, open-source Graphite alternative | Code editor for AI agents, software-factory platform | +| Positioning | Stacking ADE, open-source Graphite alternative | Code editor for AI agents, software-factory platform | | Isolation model | Jujutsu workspaces over a colocated Git repo | Git worktrees per task | | Review surface | PR-style diffs, line comments sent back to the agent | Diff and file review inside the app | | Stacked changes | Core workflow | Not emphasized publicly | @@ -27,11 +27,11 @@ Treq is built around human-in-the-loop review, stacked workspaces, and automatic ## What Each Product Does -**Treq** is a desktop app for managing parallel agent workspaces. Each workspace has its own working copy, terminal, and line of history. You review diffs like a familiar pull request, leave comments, and send that feedback back to the agent. When a lower workspace in a stack moves, Treq can rebase dependents and surface conflicts for resolution. +**Treq** is a desktop Stacking ADE. Each agent gets an isolated workspace with its own working copy, terminal, and line of history. You can arrange dependent workspaces into a stack, review each layer, and send comments back to the agent. When a lower layer moves, Treq rebases the workspaces above it and shows any conflicts. -**Superset** is a local-first desktop workspace for many coding agents. It launches CLI agents in isolated Git worktrees and surrounds them with chat, browser, review, and automation surfaces. Its public story emphasizes parallel scale, integrations with tools like GitHub, Linear, and Slack, and a path from free use into team and enterprise packaging. +**Superset** is a local-first desktop workspace for many coding agents. It launches CLI agents in isolated Git worktrees and adds chat, browser, review, and automation tools. Its public materials focus on parallel scale, integrations with GitHub, Linear, and Slack, plus paid plans for teams. -Both products assume the same basic problem: one shared checkout is a poor place for several agents to work at once. Both solve isolation with per-task working directories. +Both products solve the same basic problem. Several agents should not work in one shared checkout, so each task gets its own directory. ## Feature Comparison @@ -50,13 +50,13 @@ Both products assume the same basic problem: one shared checkout is a poor place ## Where They Differ -The shared category is parallel agents in isolated workspaces. The split is what happens next. +Both products run parallel agents in isolated workspaces. Their workflow models differ after the agents begin writing code. -Treq treats review quality as the product. Diff comments, stacked dependencies, and rebase hygiene are first-class. That matters when agents produce a lot of code. The bottleneck then moves from writing code to inspecting it and merging safely. +Treq organizes agent work as linked, reviewable layers. Diff comments return to the agent, while auto-rebase keeps the stack current. This model fits features that need several small changes in a fixed merge order. -Superset treats breadth as the product. Provider coverage, automations, remote workspaces, and team packaging are more visible in its public materials. That matters when you want one control plane for many agents and team workflows beyond a single developer's review loop. +Superset focuses on breadth. Its public materials feature provider coverage, automations, remote workspaces, and team plans. This model fits teams that want one control plane for many agents. -If "run many agents" becomes common, these differences remain. Breadth and packaging are easy for rivals to copy in messaging. Stacked review and automatic rebase are harder to fake without shipping the workflow. +Running many agents is becoming a standard feature. Treq's distinction is the stack that connects their work. That workflow must track each dependency, review layer, and rebase. ## Pricing and Licensing From 867760c06e8ffb7abaf73c21f0a8e5f004830fe8 Mon Sep 17 00:00:00 2001 From: Cursor Agent Date: Thu, 16 Jul 2026 01:01:03 +0000 Subject: [PATCH 3/3] docs: trim compare overview introduction Co-authored-by: Ziinc --- web/compare/index.mdx | 2 -- 1 file changed, 2 deletions(-) diff --git a/web/compare/index.mdx b/web/compare/index.mdx index a3728bb4..7e5bb2f1 100644 --- a/web/compare/index.mdx +++ b/web/compare/index.mdx @@ -9,8 +9,6 @@ _How Treq's Stacking ADE differs from other agent tools and stacked PR platforms Treq is a desktop **Stacking Agent Development Environment (ADE)**. It gives each coding agent an isolated workspace, then connects dependent workspaces into a stack. Review and automatic rebasing keep each layer ready to ship. -These pages put Treq next to products people often evaluate with it. Each page covers features, pricing, and the trade-offs that matter when you pick a tool. - | Comparison | Best when you care about | | --- | --- | | [Treq vs Superset](./treq-vs-superset) | Broad agent control, team packaging, and review-focused workflows |