kaanozhan/Frame

ADE( Agentic Development Environment) The spec-driven environment for AI coding agents, where your planning becomes lasting, shared project context.

Frame – Spec‑driven, AI‑orchestrated development environment

What it is – Frame is an Electron‑based desktop IDE that gives AI coding agents a durable, git‑anchored context. It creates a standard .frame/ folder in any project, storing:

AGENTS.md – project‑wide rules the agents read automatically
STRUCTURE.json – a fast intent‑index of modules
PROJECT_NOTES.md – architectural decisions that survive across sessions
tasks.json – a shared task board
specs/ – markdown‑based spec → plan → tasks → outcome workflow

The tool works with Claude Code, Codex CLI, Gemini CLI (and any future AI CLI) by injecting the .frame/AGENTS.md file at session start, so every agent begins with the same project knowledge.

Core concepts

Concept	How Frame uses it
Git commit as context anchor	Pre‑commit hooks update `STRUCTURE.json`, `tasks.json` and `PROJECT_NOTES.md`. When you start a new AI session the agent reads these files, guaranteeing it knows exactly what changed and why.
Spec‑driven development	Each feature lives in `.frame/specs/<slug>/` with four markdown files (spec, plan, tasks, outcome). The AI can generate a plan (`/spec.plan`), break it into tasks (`/spec.tasks`), and implement them (`/spec.implement`). After each task the agent writes a short outcome note, preserving the story of what was built.
Agent orchestration	A conductor agent runs ready specs in parallel, each inside its own git worktree (`.frame/worktrees/<slug>`). Footprint analysis prevents overlapping file changes, and finished work is merged only after a human approves it.
Fast file lookup	`STRUCTURE.json` contains an `intentIndex` mapping concepts to source files. Scripts like `node scripts/find-module.js github` instantly return the relevant files, saving the AI from scanning the whole repo.

Main features

Multi‑terminal grid – up to 9 real PTY terminals in a single window, resizable layout.
Task & Specs panels – visual boards; tasks can be sent directly to the selected AI tool.
GitHub integration – view issues, PRs, branches, and labels from the sidebar.
Parallel spec execution – isolated git worktrees, per‑spec branches, automatic drift checks before merging.
Multi‑AI support – Claude Code (native), Codex CLI (wrapper), Gemini CLI (wrapper). Switching tools does not lose any project files.
Pre‑commit hooks – keep the module map and task state in sync automatically.
Extensible plugins – panel for enabling/disabling Claude Code plugins; a marketplace is planned.

Typical workflow

Initialize a folder – Frame creates the .frame/ structure.
Start an AI session – pick Claude, Codex, or Gemini; the agent loads the project rules.
Write a spec – spec.md describes the feature; the AI drafts a plan.md.
Generate tasks – /spec.tasks populates tasks.json.
Orchestrate – the conductor runs multiple specs in parallel worktrees; you watch the pipeline rail.
Approve – after drift checking, you merge the spec’s branch or open a PR.
Commit – the pre‑commit hook updates the context files, anchoring the next session.

Who should use it

Teams that rely on LLM‑based code generation and need a reproducible, version‑controlled context.
Developers building large codebases where re‑explaining architecture to each new AI session becomes a bottleneck.
Product managers or technical writers who want a markdown‑first record of specs, plans, and outcomes that stays in git.

Installation & quick start

# clone and install
git clone https://github.com/kaanozhan/Frame.git
cd Frame
npm install
npm run dev   # launches the Electron app in dev mode

Pre‑built binaries are also provided for macOS, Windows, and Linux on the releases page. You need Node 16+, npm, and at least one of the supported AI CLIs.

License

Apache‑2.0 – free for commercial and non‑commercial use.

Bottom line – Frame is a concrete, open‑source tool that turns the chaotic, stateless nature of LLM‑assisted coding into a disciplined, git‑anchored workflow. It lets you keep planning, specs, and decisions in plain markdown files that any tool (or teammate) can read, while providing a UI for parallel, safe execution of AI‑generated code.