Run Claude Code, Codex, and Cursor from one window. Git version control, 28 diagram types, persistent AI memory, and isolated branching. Close everything else.
// every feature solves a real problem
Nothing was added speculatively. Each capability exists because something was broken in daily AI-assisted development. Here is what we solved, and how.
// the first problem
Working across multiple projects, personal and professional, meant Cursor in three windows, a dozen terminals, SourceTree for git, and constant context switching between all of them. The goal was simple: consolidate everything into one workspace with just what you need. No plugins, no noise.
What was built:
// code became a black box
With the latest models, you no longer review code line by line. You review by asking targeted questions. But when something gets too complex to understand through text alone, you need the AI to communicate visually. That is why diagrams were added: to give the AI a way to show you what it built, not just tell you.
What was built:
// ideas move faster than typing
If your mind generates ideas faster than your hands can type, you need tools that keep up. A new task should be one shortcut away. When even a shortcut is too slow, just speak. But a raw transcript is too shallow for an agent to execute. So the assistant takes over: it turns your rough idea into a proper ticket with a detailed description, creates it, and you can forward it to an agent immediately.
Capture fast:
Then let the assistant handle the rest:
// multiple agents, one branch = disaster
When you have multiple agents working at the same time, they cannot all be on the same branch. They will overwrite each other. So a proper branching system was needed: isolated worktrees where each agent gets its own branch, with memory propagation and manual merge-back when you are ready.
What was built:
// agents forget everything between sessions
Every time you start a new session, the agent starts from zero. All the context from yesterday, the decisions, the constraints, the architecture, gone. So persistent memory was added: per-project and per-assistant, stored locally in .aif/ and carried across every session.
What was built:
// switching apps for each engine is friction
Claude Code, Codex, and Cursor each have their strengths. You want to use all of them without switching applications. One ticket can now have multiple executions on different engines. Run the same task on Claude and Codex, compare the approaches, keep the best one.
What was built:
// complex projects need structure
A flat list of tasks does not scale. Complex projects need hierarchy, dependencies, and visibility into what blocks what. Task hierarchy replaced flat subtasks. Dependencies enforce execution order. Sub-ticket executions are grouped under their parent. And this is just the first layer.
What was built:
// more of what it looks like
Sketch on the canvas, then ask the AI to describe what it sees
Assistant generating C4 System Context and Container diagrams
C4 Container diagram showing the full system architecture breakdown
// where we are now
One window. Git version control, file explorer, terminal, rich editor, kanban board, 28 diagram types, voice input, persistent memory, three AI engines, and full orchestration. Close everything else.
AI Engines
Diagram Types
Window Needed
Other Apps
Free during beta. We'd love your feedback and feature requests.
