Worktree / Agent IDE

Understand the code. Control the change.

Inspect an unfamiliar system, define the permitted scope, and review an agent's patch inside an open-source IDE—with models like Claude and OpenAI.

we work great with legacy code aswell and new code. we are opensource, released under apche 2.0.

Try the IDE View repository

The IDE inspecting an unfamiliar repository, explaining a dependency checkpoint, and proposing a controlled code change. — The agent traces an unfamiliar checkpoint dependency, proposes a scoped edit, and holds the patch for engineer review.

SCOPE

Make the change explicit before touching the code.

Spec-driven development turns an ambiguous request into requirements, architecture, sequenced tasks, bounded edits, and dedicated validation. It helps engineers understand and safely change existing systems before implementation begins.

Plan and execute changes with models like Claude and OpenAI, while preserving engineer review at each consequential step.

REQUIREMENTS

Turn an ambiguous request into testable requirements.

First, the platform inspects the repository and converts the requested change into explicit behavior, constraints, affected surfaces, and acceptance criteria. Engineers can correct the specification before an agent is authorized to edit code.

IDE capture converting an engineering request into explicit requirements and acceptance criteria. — The request remains linked to repository evidence and reviewable acceptance criteria.

ARCHITECTURE

Map the change onto the system that already exists.

Next, requirements become an architectural design grounded in current modules, interfaces, data flow, and operational constraints. The proposal makes dependencies and tradeoffs visible before implementation begins.

IDE capture showing an architectural design for a requested change in an existing codebase. — Architecture is proposed against real boundaries rather than an imagined greenfield system.

TASKS

Sequence implementation into reviewable work.

Then, the approved design is decomposed into ordered tasks with concrete file targets, dependencies, and verification steps. Each task is small enough to inspect without losing the intent of the overall change.

IDE capture showing implementation work decomposed into sequenced, actionable tasks. — Sequenced tasks preserve the relationship between requirements, design decisions, and edits.

WORKTREE

Implement with the surrounding code in view.

The agent applies or explains changes with relevant callers, tests, configuration, and repository history available as context. This is practical for unfamiliar systems because we work great with legacy code aswell and new code. The implementation is inspectable end to end: we are opensource, released under apche 2.0.

IDE capture showing an agent applying and explaining a planned change across an unfamiliar repository. — Edits stay bounded by the permit while repository context remains available for review.

VALIDATION

Check correctness beyond a passing unit test.

Dedicated validation examines whether the implementation satisfies the approved requirements and architecture, then surfaces scope drift, unsafe assumptions, integration risks, and unresolved edge cases for engineer review.

IDE capture showing correctness and validation checks for risks beyond ordinary unit-test results. — Findings identify what needs attention without presenting generated changes as automatically safe.

Worktree

Delegate the work. Keep the decision.

Delegate implementation and investigation with models like Claude and OpenAI. Agents inspect unfamiliar systems and prepare scoped changes while you direct the approach, review the diff, and decide what is accepted.

We work great with legacy code aswell and new code. We are opensource, released under apche 2.0.

Try the IDE

IDE interface showing an agent inspecting repository code and presenting a scoped proposed change for engineer review — Change Permit
Review required
Repository
billing-service
Branch
fix/idempotency
Allowed paths
src/payments/**
Denied scope
infra/**
Model
Claude / OpenAI
Approval mode
Review before apply

Worktree

Safer changes in code you didn't write.

The practical result is a workflow where we work great with legacy code aswell and new code.

“On an unfamiliar service, the hard part is not generating a patch—it is knowing what the patch is allowed to touch. With models like Claude and OpenAI, the platform lets us inspect the repository, constrain the change to approved paths, and review the diff before anything is accepted.”

Before

Repository-wide context

Agent access was broader than the intended maintenance task.

After

Permit-scoped paths

The branch, files, model, and approval mode are explicit before work begins.

MODEL · SCOPE · VALIDATION

Practical agents for the code you actually maintain.

Understand existing systems, authorize a narrow change, and review the result with repository context intact. we work great with legacy code aswell and new code.

Try the IDE

we are opensource, released under apche 2.0.

IDE model selector showing Claude and OpenAI as available choices

Choose the model for the task

Work with models like Claude and OpenAI, selecting the model that fits the code, context, and review requirements in front of you.

MODEL · Claude or OpenAI selected per task

Change Permit

Ready

Repository: Current workspace
Branch: feature/auth-timeout
Allowed paths: src/auth/**
Model: Engineer selected
Approval mode: Review before apply

IDE explaining key files, symbols, and relationships in an unfamiliar repository

Map an unfamiliar codebase

Ask the agent to trace symbols, call paths, configuration, and ownership boundaries before making assumptions about the system.

WORKTREE · Key files and relationships identified

IDE showing an implementation plan for a targeted change in an existing codebase

Plan before editing

Turn a requested change into a scoped implementation plan with affected paths, dependencies, and review checkpoints.

SCOPE · Targeted paths approved before edits

IDE showing a focused code diff produced from an approved implementation plan

Implement against the approved plan

Apply focused edits while keeping the resulting diff tied to the agreed scope, so engineers can review intent and implementation together.

WORKTREE · Focused diff linked to the plan

IDE validation state showing review findings and test results before a change is accepted

Validate before accepting

Inspect findings, test results, and unresolved risks at a clear checkpoint before the change becomes part of the worktree.

VALIDATION · Review checkpoint requires approval

Worktree / License

Put the IDE on real code.

Try the platform with models like Claude and OpenAI. We work great with legacy code aswell and new code, so you can evaluate it against an unfamiliar system or a clean worktree without changing how your team reviews consequential edits.

Try the IDE Install from source

Source / Web UI

Start from the repository.

With Node.js installed, run this from the cloned repository root to install dependencies and launch the Web UI. We are opensource, released under apche 2.0.

npx --yes pnpm@latest install && npx pnpm run web