Blog

Product update

Nora 2: native threads, and a team of bots

The first versions of Nora were built around a simple idea: put your coding agents' terminals side by side and give them isolated worktrees. Nora 2 keeps what worked and replaces the part that didn't. Agents now run natively inside Nora, every conversation is a thread, and bots let you build a small team you can come back to.

Published · Citosoft

Why we stopped wrapping terminals

Running Claude Code or Codex in an embedded terminal got us started quickly, but it meant Nora could only see text. To know whether an agent was busy, waiting for permission or finished, we had to read its screen. Approvals were terminal prompts. Handing context from one agent to another meant typing into a shell. When the app restarted, the only record of the work was a scrollback buffer.

That ceiling showed up everywhere: status that guessed, approvals you could miss, context that was hard to move, and a UI that could never be calmer than the CLI underneath it. So we rebuilt the core.

Native agents

Nora 2 talks to each agent through its own SDK or protocol: the Claude Agent SDK for Claude Code, the Codex app server for Codex, and the Agent Client Protocol for agents such as Cursor, OpenCode, Google Antigravity, Grok, Copilot, Goose and Kimi.

Because Nora receives structured events instead of terminal output, it can show what is really happening. Models, reasoning options and permission modes come from the runtime itself. Tool calls collapse into a single live activity line you can expand. Approvals open in a dialog with the agent's real choices, questions arrive as cards in the thread, and requests from other threads gather in a tray so nothing waits unseen. Your context window and usage limits sit beside the composer.

We also narrowed the list of supported agents to the ones we can integrate properly: Claude Code, Codex, and anything that speaks ACP.

Everything is a thread

In earlier versions, an agent session, its terminal and an AI chat were three different things. In Nora 2 they are one: the thread. A thread remembers its workspace, branch, agent, model, permission mode, queued messages, history and the files it changed, and it keeps running when you close the tab or switch away.

Starting work is just starting a thread. The new thread screen is the chat itself, with the workspace, branch and model chosen inline instead of in a launch dialog. Keep typing while a turn runs and your follow-ups queue, or steer the turn on agents that support it. When a thread is done, settle it: it leaves your list without losing anything, and you can reopen it later. Nora even finds the Claude Code and Codex conversations you started outside the app, so you can pick those up too.

Under the hood, threads are durable. They survive restarts, record before-and-after checkpoints for each turn so reviews show exactly what that turn changed, and never silently repeat an instruction Nora isn't sure was delivered.

Meet the bots

Once agents were native, a new idea became possible. A bot is a reusable teammate: a name, a one-line role, standing instructions, a model, optional memory and an animated face whose eyes show what it is doing. Create one yourself, start from one of twelve templates such as Code reviewer, Researcher or Planner, or just ask Nora to make one for you.

When you message a bot, it works in its own thread, keeping the instructions it started with. Bots can live everywhere or with one workspace, and workspace bots can be shared with your team as files in .nora/bots.

Bots that work together

Bots are more useful together. Any bot, or Nora itself, can ask another for help: the asked bot answers in its own read-only thread with its own model, and the reply comes back as a card. @mention a reviewer in the middle of your work and you get a second opinion without leaving the thread.

For bigger jobs, start a group chat with two to six bots. Members you mention reply one at a time, @everyone asks them all, an optional lead picks up the rest, and only the member you choose can change files.

Bots that remember

Bots with memory keep short, durable notes across threads: your preferences, decisions and project facts. They save, correct and search those notes themselves, and when a thread goes quiet a background review picks out what is worth keeping. Every note is visible and editable in the bot's settings, and notes never change what a bot is allowed to do.

Not just for code

Nora is still a development tool first, but much of the work around software isn't code: specs, plans, research, release notes, decisions. On first launch Nora 2 asks what kind of work you do, and your answer shapes the tools it pins, the starters it suggests and the guidance your agents receive. Roles never grant permissions or change your model.

You also no longer need a repository to start. Nora creates a Personal workspace for you, so you can plan, write or research from the first minute and open a project when you need one.

What stays

The workbench you know is still here. Terminals remain, now purely for your own commands, dev servers and presets. Worktrees still isolate parallel work, and every thread can open a PR or MR from its own checkout. The Git tab, commit history, diffs, the built-in browser, tasks, specs, workflows, GitHub, GitLab and Vercel tools, and remote projects over SSH all come along, now wired to threads instead of terminal sessions.

What's next

Nora 2 is the foundation we wanted from the start: native agents, durable threads and a team you can build on. Read the docs to see how it all fits together, and tell us what you'd like your bots to do next.