WHY NEXUS?
Give every agent the project context it is missing.
AI agents are powerful, but their understanding of a project is temporary. Important decisions, instructions, earlier investigations, and team responsibilities disappear between sessions or remain scattered across tools.
Nexus preserves that context and turns it into coordinated work for specialized Actors, human teams, and the private infrastructure they control.
Your project should know more than the current session.
NEXUS OPERATING MODEL
Project Intelligence
ADRs · Directives · Documents · Research · Sessions
↓
Named Actors
Who performs the work
Nexus Dispatch
How work moves
↓
Human Governance
Who reviews and decides
↓
Private AI Control Plane
Where controlled work runs
THE PROBLEM
Agent intelligence is powerful. Project understanding is fragile.
Session-bound context
Architectural decisions and earlier discoveries must be explained again when a new session begins.
Inconsistent instructions
Different users, tools, and workstations provide different rules to the same project.
Lost coordination history
Blockers, reviews, and cross-project findings remain in transient chats or disconnected ticket systems.
Disconnected private infrastructure
Sensitive workloads require private models and hardware, but governance and infrastructure control are separated.
WHAT CHANGES
From session-bound assistance to durable project intelligence
Nexus does not make the model smarter. It gives the model a better project to work from.
THE NEXUS MODEL
Persistent context becomes coordinated execution
Five layers work together: project intelligence at the foundation, named actors and dispatch for coordination, human governance for decision authority, and private AI infrastructure for controlled execution.
Project Intelligence
What does the project know? — ADRs, directives, sessions, research notes, ingested documents
Named Actors
Who performs the work? — Roles, skills, attribution
Nexus Dispatch
How does work move? — Routing, lifecycle, audit
Human Governance
Who reviews and decides? — ADR lifecycle, voting, review gates
Private AI Control Plane
Where does controlled work run? — Cortex inference, nexus-link hardware, signed commands
Cost & Operations Intelligence
Cross-cutting — Token usage, estimated spend, budget awareness per session and project
Signature capabilities
Named Actors
Build an agent team, not one generic assistant
Who performs the work
Register human and agent Actors in the project registry. Each receives tailored context, directives, and skills — making every interaction role-appropriate.
- Actor registry with role definitions
- Skill assignment per Actor or project
- Attribution on every session and action
- Cross-project actor resolution
Nexus Dispatch
Route work across project boundaries
How work moves
Nexus Dispatch gives every coordination event a lifecycle: creation, acknowledgement, progress, resolution, and close. Agents and humans participate in the same channel.
- Cross-project routing with full context
- Blocking and non-blocking dispatch types
- Append-only message timeline for audit
- Automatic duplicate and loop detection
Human Governance
Agents can propose. Teams can review and decide.
Who reviews and decides
Agents draft decisions; humans accept or reject them. Directives set boundaries. Review workflows ensure consequential changes pass through human judgement.
- ADRs with draft → review → accepted lifecycle
- Project directives synced to all agents
- Review and voting on critical changes
- Decision audit trail with rationale
Private AI Control Plane
Operate controlled AI workloads from the same platform that governs them
Where controlled work runs
Cortex provides local inference and nexus-link manages hardware — both connected to the same governed project context. Selected processing can remain inside infrastructure controlled by the organization.
- Cortex local extraction and embeddings
- Inference on controlled hardware
- nexus-link hardware and model telemetry
- Signed write commands and config
OPERATIONS
Cost & Operations Intelligence
Every session records token usage and estimated cost. Understand where budget goes before it is spent.
Input tokens · Output tokens · Reasoning tokens · Cache hits · Estimated USD per session
One workflow, from project context to reusable resolution
Project Intelligence
Define the accepted project context
Named Actors
Assign responsibility
Nexus Dispatch
Route cross-project work
Human Governance
Review consequential changes
Private AI Control
Use controlled execution boundaries
Project Intelligence
Preserve the outcome
Every resolution enriches the project. Every session that follows starts with more knowledge than the last.
Scenarios that matter
Cross-project blocker resolution
Situation: An agent in Project A encounters a dependency owned by Project B. The teams use different tools and runtimes.
Friction: Without shared coordination, the blocker becomes a copied ticket, loses context in transit, and waits for a human to bridge two systems.
Nexus workflow: A Dispatch is routed cross-project with full context. The receiving team sees the blocker, its origin, and the requesting Actor.
Result: The blocker reaches the correct owner with its technical context intact. Its resolution remains searchable after closure and becomes reusable project knowledge for future Actors.
Long-running development
With Nexus: Nexus preserves decisions, task progress, and session history. Every agent resumes with full project awareness.
Result: No more "starting over" between sessions.
Multi-Actor delivery
With Nexus: Named Actors coordinate through Dispatch. Backend and frontend Actors operate from shared decisions.
Result: Consistent architecture without manual synchronization.
Architecture governance
With Nexus: ADRs define accepted patterns. Directives enforce them. Review gates catch deviations before they propagate.
Result: Architectural drift detected early, not in production.
Confidential local AI
With Nexus: Cortex supports local extraction, classification, summarization, and semantic search. Selected processing can remain inside controlled infrastructure.
Result: AI capability without requiring data to leave the organization.
IN PRACTICE
Built for agent-assisted work that outlives one prompt
Solo developers
Re-explaining context every session
Small teams (2–8)
No shared governance across agents
Tech leads
Inconsistency in agent-generated output
Platform engineers
Building custom coordination glue
Security-conscious teams
Data leaving the machine
GETTING STARTED
Start with one project
Connect
Create or connect one Nexus project.
Initialize
Install nexus-cli and run nexus init.
Synchronize
Run nexus pull to materialize project context and MCP configuration.
Govern
Add one important ADR, Directive, or reviewed agent instruction.
Run
Launch the project through nexus run.
Expand
Introduce named Actors, Nexus Dispatch, team governance, and private AI as needed.
Start with one project and keep the agent runtime you already use.
Read the getting-started guide→BUILT IN THE OPEN
Evaluate Nexus through public evidence
Review the product’s current state through published releases, open components, documentation, and roadmap.
Status
Public Alpha
Visible releases with breaking-change warnings.
Components
Open Components
CLI, nexus-link, and OpenCode plugins (Apache-2.0).
Visibility
Published Roadmap
What's New, Roadmap, and Documentation.
Steward
Named Maintainer
RelicFrog Holding UG — sustainable pace, honest communication.
Your project intelligence, persistent and portable. Your Actors, coordinated and governed.
Agents and harnesses change. Your specifications, decisions, responsibilities, and coordination history should not have to.
Start with one project and your existing agent runtime. Add durable context first, then introduce Actors, Dispatch, team governance, and private infrastructure as your workflow grows.