Diri
A native workspace for coding agents: run terminal agents in parallel and review their changes in place.
Evidence shows agents run locally under the user account in real terminals with no hosted relay; SECURITY.md scopes permission-boundary bypasses and credential disclosure as vulnerabilities; actions are SHA-pinned, cargo is --locked, weekly CodeQL runs, and a license-policy check exists. Deductions: no direct evidence in these files of user-confirmation gates for agent actions, sensitive-data (token/terminal output) handling policy, data-flow documentation, or rollback mechanics — SECURITY-MODEL.md, NOTICE, and PRIVACY.md are referenced but not provided, capping confirmation/transparency/sensitive-data at 1.
Evidence shows a serious CI: separate macOS test job, Linux engine tests against real child processes, clippy -D warnings, fmt checks, with detailed comments on concurrency, caching, and timeouts, and specific notes on known failure modes (empty simulator device lists, required-check renaming). Deduction: reliability evidence is confined to the build pipeline; runtime error-handling quality cannot be confirmed from static files.
Evidence shows unusually specific environment fit (macOS 15+, Apple silicon/Intel; Linux beta on Ubuntu 22.04/24.04, X11/Wayland, Vulkan 1.3), a clear audience (developers running multiple coding agents in parallel), and differentiated integration depth for Claude Code/Codex. Deductions: this is not a manifest-triggered agent so trigger precision has no evidence; capability-boundary material (LINUX.md limitations, security model) is referenced but not in scope.
Evidence shows complete install notes (brew cask, DMG, Linux source builds), full Apache-2.0 text, clean document architecture, a dedicated Linux limitations guide, and a security policy with supported versions and a seven-day acknowledgement commitment. Deductions: no changelog evidence, no versioning policy in the files, examples/FAQ exist only as external links outside the evidence, NOTICE content is absent — hence 1–2 on those.
Evidence shows a clear product thesis: run multiple terminal coding agents in parallel, isolate tasks in Git worktrees, review diffs in place, and keep sessions alive across app restarts; it reuses the user's existing agent CLIs and accounts, avoiding hosted cost. Deduction: all utility claims come from README marketing prose with no quantified or independently checkable output evidence beyond a screenshot reference.
Evidence shows high candor in CI commentary — concrete numbers (5-minute PR budget, ~3 minutes compiling) and clear fact/design-reason separation. Deduction: key README claims (signed and notarized builds, session persistence, depth of resume integration) are not traceable within the provided files; all supporting docs are links whose content was not reviewed, so traceability, corroboration, and fact/inference separation score only 1.
- Publisher identity is unverified by the enterprise registry; supply-chain trust rests entirely on the GitHub repository itself.
- The app runs local shells, coding agents, and optional remote commands with full user privileges; this review could not verify confirmation gates or isolation — read docs/SECURITY-MODEL.md before adopting it in sensitive environments.
- Key security and privacy documents (SECURITY-MODEL, PRIVACY, NOTICE) are referenced by link only; their contents were not verifiable in this static review.
- No changelog or versioning policy evidence exists; security fixes target the latest release only, so keep both Diri and the agent CLIs it launches current.
- Linux is beta and packages are not included in every release; assess stability before production use.
What does this agent do, and when should you use it?
Diri is a native desktop workspace built with Rust and GPUI for running terminal coding agents such as Claude Code, Codex, Cursor, and Gemini side by side. It does not host or wrap models; it invokes agent CLIs already installed on your machine, running them in real terminals under your user account. Each task can get its own Git worktree and branch so parallel agents stay isolated. The app provides live status and notifications distinguishing working, waiting, and finished sessions, and lets you inspect diffs, stage changes, commit, and follow PR checks beside the session. It targets macOS (15+, signed and notarized) with Linux in beta, and requires no Diri account or hosted relay.
Diri launches and manages agent CLI sessions (Claude Code, Codex, etc.) locally or on SSH hosts you control. It gives each task its own Git worktree and branch, shows live status (working/waiting/finished) per session with notifications, displays code diffs for in-place review with staging, committing, and PR check tracking, and keeps local sessions running across app restarts or Engine restarts. On remote hosts, Diri handles Helper setup automatically. Claude Code and Codex have the deepest status and resume integration.
- A developer juggling multiple coding tasks at once: give each task its own worktree and let different agents work in parallel without conflicts.
- Engineers whose primary tools are Claude Code or Codex: get the deepest session status and resume integration and return to unfinished work anytime.
- Users who want agents on multiple machines: run locally or on an SSH host you control, with Diri handling remote Helper setup.
- Teams that review code carefully: inspect diffs, stage changes, commit, and follow PR checks right beside each agent session.
- Security-conscious users: agents run under your own account in real terminals, with no third-party hosted relay involved.
What are this agent's strengths and limitations?
- Real multi-agent parallelism: tasks are isolated with Git worktrees and branches instead of multiple agents competing for one working directory.
- Deep status and resume integration: Claude Code and Codex sessions keep running and are resumable across app or Engine restarts.
- Local-first architecture: agents run under your user account in real terminals; no Diri account, hosted relay, or code upload to a third party.
- In-place review workflow: diff viewing, staging, committing, and PR check tracking happen beside the session, reducing tool switching.
- Works on your own machines: run locally or on SSH hosts, with Diri handling remote Helper setup.
- Limited platform coverage: macOS requires 15+; Linux is in beta, restricted to x86_64 Ubuntu 22.04/24.04 (X11/Wayland, Vulkan 1.3), and Linux packages are not shipped in every release; no Windows support.
- External tool dependency: you must install each agent CLI yourself and use its existing accounts and billing; Diri ships no model access.
- Uneven integration depth: only Claude Code and Codex have the deepest status and resume integration; other agents may have a more limited experience.
- Remote session persistence depends on the host; Diri only reports persistence capabilities and cannot guarantee consistent behavior.
- Linux deployment may require building from source, which is more involved than the Homebrew install on macOS.
How do you install or deploy this agent?
Install via Homebrew: brew install --cask cristicretu/diri/diriRequires macOS 15 or newer; Apple silicon and Intel supported (signed and notarized). Alternatively download the DMG from GitHub Releases and drag Diri to Applications.
Linux beta: x86_64 Ubuntu 22.04 / 24.04, X11 or Wayland, Vulkan 1.3. Linux packages are not included in every release; see the Linux guide (diri/LINUX.md) for packages and source builds.
Agent CLIs (e.g. Claude Code, Codex) must be installed separately; Diri uses the tools and accounts already on your machine.
How do you use this agent?
After installing and launching Diri, start sessions with your installed agent CLIs (e.g. Claude Code or Codex) and manage multiple parallel sessions from the sidebar. Assign each task its own Git worktree and branch; use live status and notifications to see which sessions need you; review diffs, stage, commit, and track PR checks beside the session. Sessions run locally or on SSH hosts; local sessions keep running after you close the app and can be resumed.