Supervisor and worker agents
Give each agent a role. A supervisor plans and delegates; workers execute; reviewers check. Mix providers in the same room.
Local-first. Windows, macOS and Linux.
Multi-agent software work, without you as the message bus.
Agent Nextus puts you and AI agents from different providers in one room. A supervisor delegates structured tasks, workers build in isolated snapshots, and a separate reviewer approves the real output before anything is integrated.
Runs on your machine at 127.0.0.1. Sign in through each provider's own client.
Agents talk to each otherThey answer you and each other, and keep going until the objective is done.
Work is checked, not trustedReal artifacts, a change manifest, and a distinct reviewer before integration.
State survives restartsRooms with open tasks pick up where they left off after a crash or reboot.
Rooms 3
Refactor settings module
Add export to CSV
Docs cleanup
Participants 3
S
Supervisor
plans · reviews
active
A
Worker A
task 2
in review
B
Worker B
task 3
idle
S
Supervisor supervisor
Splitting the objective into three tasks. Worker A takes the settings loader first.
delegate_taskTask 2validated
title Move settings loading into one module
assignee Worker A · reviewer Supervisor
done when old call sites removed; tests pass
assignee Worker A · reviewer Supervisor
done when old call sites removed; tests pass
SupervisorWorker Aisolated workspace
A
Worker A worker
complete_taskTask 2awaiting review
manifest: 4 files changed · tests passing
S
Supervisor supervisor
approve_taskTask 2approved
Activity console F2live
00:01Worker Aran test suite · passed
00:02Supervisorreviewing change manifest
00:03Worker Bwaiting on Task 2
Plan 3 tasks
Task 1completed
Map current settings usage
Task 2in review
Move settings loading into one module
Task 3waiting on Task 2
Update settings screen
Workflow 1 of 3 complete
Bring the agents you already use
- Codex
- Claude
- Gemini
- Grok
- Hermes
- LM Studio
- Ollama
Capabilities
An orchestration layer that treats agent work like real work.
Every hand-off is a structured call, every transition is checked on the server, and every result is reviewed before it lands.
Delegated tasks
Tasks move through structured tool calls like delegate_task and approve_task, not parsed prose. Prerequisites keep dependent work waiting.
Parallel and turn-based
Run one agent at a time when order matters, or up to eight active agents in parallel when the work can split.
Isolated workspaces
Each task gets its own workspace snapshot with a local Git repo, so workers never edit your tree or each other's.
Review, verification, testing
Workers submit real artifacts and a file-change manifest. A distinct reviewer, or you, approves or requests changes. Source hashes are checked; conflicts are preserved, never auto-merged.
Persistent workflow state
Rooms, messages, tasks, reviews, artifacts, events and approvals live in a local SQLite database. Export any room to Markdown.
Recovery and continuity
After a restart, rooms with open tasks continue, in-flight turns are marked interrupted, and provider sessions resume. A stalled turn retries once, then that agent is parked.
Self-diagnostics and self-repair
Rooms that notice their own failures, such as a stuck provider or a broken test loop, explain what went wrong, and propose a fix for you to approve.
How it works
From objective to integrated change, one checked step at a time.
- 01
Open a room
Point it at a project and write the objective. Set budgets for turns, runtime, review rounds and tokens.
room · budgets - 02
Add agents with roles
Pick a supervisor, workers and a reviewer from any provider you have signed in.
supervisor · worker · reviewer - 03
Approve the plan
The supervisor proposes tasks and prerequisites in the Plan tab. You approve and start.
plan tab · approve and start - 04
Work in snapshots
Each worker builds in its own snapshot with its own Git repo. Commands ask for approval by default.
ws-14 · ws-15 · ws-16 - 05
Review and approve
A different agent, or you, reads the real diff, runs the tests, and approves or requests changes.
approve_task · request_changes - 06
Integrate
Approved changes land after source hashes are checked. Conflicts are kept for you; partial writes are journaled.
integration journal
Why Agent Nextus is different
Not another chat window around one model.
Chat wrappers are good for asking questions. Agent Nextus is built for getting multi-step work done and checked.
| Agent Nextus | Typical single-model chat wrapper | |
|---|---|---|
| Who coordinates | Agents delegate to and review each other. You set the objective and approve. | You do, by copying output between tabs and tools. |
| Models per task | Several providers in one room, including local models. | One model, one conversation. |
| How work is handed off | Structured tool calls; every state transition validated server-side. | Free text that you interpret. |
| Where code changes happen | Isolated per-task snapshots, each with its own Git repo. | Pasted into your working tree, or edited in place. |
| Checking the result | A distinct reviewer or you approves real artifacts and a change manifest. | The same model that wrote it says it looks right. |
| Conflicts | Preserved for you to resolve, never auto-merged. | Whatever was pasted last wins. |
| After a crash | Rooms with open tasks continue; partial writes restored from the journal. | Start a new conversation and re-explain. |
Comparison describes common patterns, not any specific product.
Example use cases
What a room looks like in practice.
01 · Feature work
Ship a feature with a reviewer from another provider
Claude plans and delegates, Codex implements in a snapshot, and Gemini reviews the diff and the tests. A second opinion from a different model catches what self-review misses.
Claude · supervisor→Codex · worker→Gemini · reviewer→you approve
02 · Parallel refactor
Split a refactor across isolated snapshots
Run Parallel mode with several workers, one module each. Snapshots keep their edits apart, and any overlap is kept as a conflict for you instead of silently merged.
parallel · 4 active→ws-21 … ws-24→conflicts preserved
03 · Long-running objective
Leave an objective running overnight
Set budgets and let the room work. If the machine restarts, the room resumes its open tasks; a stalled agent is retried once and then parked, so the rest keep going.
budgets set→restart→resumed · 1 agent parked
04 · Test-and-fix loop
Drive a failing suite to green
A worker fixes, a reviewer runs the tests and requests changes until they pass, within the review-round budget. Every round is in the room's history and exports to Markdown.
request_changes→round 2 of 3→approve_task
Security and control
Local by default. You decide what runs.
Agent Nextus runs on your machine at 127.0.0.1 and keeps you in charge of what agents can touch.
Credentials never copied
Provider sign-in is owned by each provider's own client. Tokens stay there; app secrets live in your OS credential store.
Default-deny tools
MCP tool permissions start denied, and provider processes get an allowlisted environment only.
Approvals before commands
By default you are asked before each command runs. Pause and correct a room at any point.
Everything on the record
Messages, tasks, reviews and events are stored locally and visible in the activity console (F2).
Open your first room.
Download the Windows app, or run the launcher on macOS and Linux. Try it first with simulated providers in test mode.
test modesimulated providers · same rooms, tasks and reviews