diff --git a/web/compare/index.mdx b/web/compare/index.mdx new file mode 100644 index 00000000..7e5bb2f1 --- /dev/null +++ b/web/compare/index.mdx @@ -0,0 +1,21 @@ +--- +sidebar_position: 1 +description: Compare Treq's Stacking ADE with agent development environments, terminal tools, and stacked PR platforms. +--- + +# Compare + +_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. + +| 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..154d5755 --- /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 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 | 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 | +| 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. 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. + +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..0b9657b9 --- /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. Each coding agent gets its own workspace, branch, files, terminal, and review path. Their models diverge when tasks depend on one another. + +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 | 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 | +| 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 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. + +## 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): 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 new file mode 100644 index 00000000..3f37f10f --- /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 ADEs with different models for multi-agent work._ + +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 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 | 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 | +| 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 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** 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 use Apache 2.0, so licensing does not separate them. + +## 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 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 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. + +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 + +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. +- 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: + +- 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..17672c03 --- /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 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. + +## At a Glance + +| | Treq | Graphite | +| --- | --- | --- | +| 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 | +| 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 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. + +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 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. + +## 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..f5e6750e --- /dev/null +++ b/web/compare/treq-vs-orca.mdx @@ -0,0 +1,95 @@ +--- +sidebar_position: 7 +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 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 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 | 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 | +| 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 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. + +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. +- 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: + +- 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..ceba9d04 --- /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 ADEs for different workflows: stacked changes or broad agent control._ + +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 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 | 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 | +| 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 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 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 solve the same basic problem. Several agents should not work in one shared checkout, so each task gets its own directory. + +## 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 + +Both products run parallel agents in isolated workspaces. Their workflow models differ after the agents begin writing code. + +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 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. + +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 + +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 c33722b6..6bb2e4da 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;