Nora | CLI-first agentic development workspace

Nora

agentic development

Beta

$ cli-first$ local agents$ human approvals

Quick Start

install.linux

# install nora for linux

$curl -fsSL https://withnora.run/install.sh | bash

$ workspace preview$ session: local / mode: operator

Nora application screenshot showing the agentic development workspace.

$ supported clis

Download Read docs

$ available on

macOS

Windows

Linux

$ operating path

One path from intent to merge-ready output.

Scope

Execution boundaries and constraints

Spec

Requirements and acceptance criteria

Tasks

Actionable units with ownership

Agents

Parallel implementation in worktrees

Diffs

Review and validation checkpoints

Open Pull Request

Approval-ready pull request

$ handoff

Hand tasks from one agent to another without losing context.

Keep the brief, current repo state, and task intent intact as work moves between agents instead of restarting the conversation every time a different tool takes over.

Flow

$ task: refine download flow

codex

claude

review

$ task to agent handoff

$ shared context

$ visible ownership

$ scope

Derive tasks directly from scope.

Start from the shape of the work itself and let Nora break that into actionable units instead of manually rewriting the same plan for every agent session.

Planning

$ scope.txt

1. define installer paths

2. build download surface

3. wire release metadata

$ scope -> task breakdown

$ clear execution units

$ less prompt drift

$ skills

Attach the right skill set to the run.

Use a skill manager to bring specialized instructions and workflows into the session without bloating the default agent prompt.

Extensions

+ electron

+ frontend

+ tailwind

+ docs

$ skill manager

$ task-specific context

$ lighter defaults

$ worktrees

Give every agent its own isolated worktree.

Keep experiments, edits, and reviews separate by default so parallel work does not turn the main branch into a collision zone.

Repo isolation

agent-a

worktree-1

agent-b

worktree-2

agent-c

worktree-3

$ isolated worktrees per agent

$ parallel edits

$ clean merge path

$ file editing

Edit repository files directly in the workspace.

Apply targeted edits where the work is happening instead of bouncing between disconnected tools. Nora keeps file editing in the same operational surface as the rest of the run.

Editing

$ src/app/page.tsx

find: "hero copy"

+ <BuiltInBrowserCallout />

- legacy CTA text

$ in-workspace edits

$ targeted patches

$ faster iteration

$ browser preview

Use the built-in browser to view what you're building.

Preview routes, verify UI behavior, and check rendered output without leaving Nora. The built-in browser keeps visual validation inside the same loop as agent execution.

Preview

$ diffs

Review code diffs before changes move forward.

Inspect exactly what changed, keep reviews explicit, and catch regressions earlier. Diff visibility is built into the workflow so operator approval stays grounded in code.

Review

$ git diff

src/components/feature-sections.tsx

+ <DownloadCta />

- old hero paragraph

$ git diff visibility

$ change auditing

$ approval-ready output

$ screenshots

Paste screenshots into terminal-based agents.

Bring visual context directly into CLI agent workflows. Nora lets you paste screenshots into terminal-based agents, which is not something they support natively on their own.

Visual context

$ paste screenshot

png

attached screenshot: login-state-bug.png

terminal agent can inspect UI regressions with visual context

$ paste screenshots

$ attach visual bugs

$ terminal agents with images

$ ide handoff

Hand work back to the IDE you already prefer.

Use Nora as the operating layer, then jump into your preferred editor for deeper inspection, local debugging, or final polish without losing the thread of the work.

Preferred editors

$ open in editor

current worktree

$ open current worktree in your IDE

$ keep your familiar editing flow

$ nora stays the control plane

$ remote

Manage SSH-mounted repos like local projects.

Remote work should feel first-class. Nora is being shaped around SSH mount management so remote repositories can be operated on with the same clarity as local ones.

Remote mode

$ ssh mounts

prod-web-01mounted

staging-api-02ready

$ ssh mount management

$ remote terminals

$ remote agents

$ integrations

Connect the delivery layer, not just the editor.

Source control and deployment need to stay in the same flow. GitHub and Vercel integrations are part of the working surface, not an afterthought.

Connected stack

synced

$ github integration

$ gitlab integration

$ vercel integration

$ release context

$ visibility

See the entire operation in a multi-agent grid view.

Track active agents, task status, ownership, and repo progress in a layout that is meant for operating a system, not just reading a transcript.

Control plane

agent-01

agent-02

agent-03

agent-04

agent-05

agent-06

$ multi agent grid view

$ live task state

$ operator overview

$ faq

Questions visitors usually ask first.

A quick overview of what Nora does, who it is for, and how it fits into an agent-driven development workflow.

What is Nora?+

Nora is a CLI-first workspace for running agentic development workflows with local agents, isolated worktrees, and explicit operator control.

Which coding agents does Nora work with?+

The current product direction is built around tools like Claude Code, Codex, Gemini, and Cursor, with the goal of giving them a shared operational workspace instead of separate silos.

Does Nora run agents locally?+

Yes. Nora is designed around local-first execution so you can operate agents against your repository with direct visibility into files, diffs, and task ownership.

Why use isolated worktrees?+

Separate worktrees let multiple agents explore, edit, and review in parallel without stepping on the same branch, which makes merges and human approvals much cleaner.

$ ade vs ide

What Nora does that a traditional IDE fundamentally does not.

capability

nora

ides & wrappers

Single control plane for multiple live coding agents

Nora

yes

IDEs & wrappers

Agent-to-agent handoff with preserved task context

Nora

yes

IDEs & wrappers

Cross-agent task orchestration from one operator surface

Nora

yes

IDEs & wrappers

Terminal-native screenshot context for CLI agents

Nora

yes

IDEs & wrappers

Worktree-isolated parallel execution as the default model

Nora

yes

IDEs & wrappers

In-loop browser preview tied directly to agent workflow

Nora

yes

IDEs & wrappers

Shared operational view of ownership, progress, and outputs

Nora

yes

IDEs & wrappers

Repo operations, diffs, and agent runs in one execution layer

Nora

yes

IDEs & wrappers