Network-AI Coordination infrastructure for serious agent systems
Production-grade multi-agent control plane

Orchestrate agents without trusting them blindly.

Network-AI sits between your agents and your shared state. It adds locking, permission gating, budgets, audit trails, and workflow governance so parallel agent systems behave like production software instead of best-effort demos.

Read the code Watch demos
16 adapters supported 1,582 tests passing 20 suites MIT licensed
Atomic shared state

Use propose -> validate -> commit with a file-system mutex instead of last-write-wins race conditions.

Permission-first execution

Score justification quality, trust level, and resource risk before any sensitive operation is allowed.

Traceable operations

Record grants, denials, writes, transitions, and token actions in a tamper-evident audit log.

Cross-framework by design

Wrap existing agents instead of replacing them. Keep your stack and add governance on top.

The failure mode most agent demos skip.

Parallel agents do not usually fail loudly. They fail by silently overwriting state, bypassing policy, drifting across workflow stages, and leaving you with no reliable audit trail.

Default multi-agent behavior

Best-effort coordination breaks under pressure.

When multiple agents operate on the same system, most frameworks assume cooperation instead of enforcing it. That works in a toy run. It breaks in production.

  • Shared keys get overwritten with no conflict detection.
  • Tool calls happen without pre-authorization or scoped credentials.
  • Agents carry stale state across tasks and workflow phases.
  • Postmortems lack a trustworthy sequence of who did what and why.
Network-AI approach

Turn agent activity into governed system behavior.

Network-AI adds a thin control plane around your existing agents: lock shared writes, gate tool access, enforce state transitions, and log every sensitive action with enough integrity to audit later.

  • Atomic blackboard writes prevent split-brain state.
  • AuthGuardian issues HMAC / Ed25519-signed scoped tokens with TTL.
  • JourneyFSM blocks agents from skipping authorized stages.
  • ComplianceMonitor watches behavior continuously, not after the fact.

Built for teams shipping real agent workflows.

The project is opinionated about coordination quality: explicit permissions, constrained state, deterministic workflow control, and integration paths that do not lock you into one ecosystem.

State integrity

Locked blackboard coordination

Shared state is protected by atomic propose -> validate -> commit semantics with a file-backed mutex.

  • Conflict-safe writes
  • Validation before commit
  • Persistent local-first storage
Security model

Permission gating with scoped tokens

Agents must justify access before touching protected resources. Grants are signed, scoped, and time-limited.

  • 40/30/30 weighted scoring
  • HMAC / Ed25519-signed grant tokens
  • Fine-grained resource protection
Behavior control

Workflow governance and compliance

Finite-state workflow enforcement and runtime surveillance keep agents aligned with the path you define.

  • JourneyFSM state enforcement
  • ComplianceMonitor policies
  • Real-time violation handling

One orchestration layer, many agent stacks.

Network-AI is additive. You keep CrewAI, LangChain, AutoGen, MCP, or NemoClaw, and add a control plane above them.

Agent frameworks
CrewAI, LangChain, AutoGen, OpenAI Assistants, NemoClaw, MCP, and more route through adapters.
Control plane
LockedBlackboard, AuthGuardian, FederatedBudget, JourneyFSM, ComplianceMonitor, and validation layers.
Outputs
Governed execution, auditability, scoped access, deterministic transitions, and cleaner failure boundaries.

Watch the system under load.

The fastest way to understand the product is to watch the orchestration layer mediate real workflows, guardrails, and sandboxed execution paths.

Code Review Swarm demo
05 | Code Review Swarm See a multi-agent review pipeline coordinate analysis, remediation, and output generation.
Control Plane Stress demo
08 | Control Plane Stress Watch locks, FSM rules, compliance monitoring, and orchestration constraints hold under pressure.
NemoClaw Sandbox Swarm demo
10 | NemoClaw Sandbox Swarm Three isolated sandboxes, deny-by-default networking, and blackboard coordination across agents.

Start small. Keep the same control model as you scale.

The quick-start path stays direct: install, register an adapter, execute an agent, and let the orchestration layer manage the dangerous parts.

Quick start
# install
npm install network-ai

import { createSwarmOrchestrator } from "network-ai";
import { AdapterRegistry, CustomAdapter } from "network-ai/adapters";

const orchestrator = createSwarmOrchestrator({
  agentId: "my-app",
  swarmName: "Production Swarm",
});

const adapter = new CustomAdapter();
adapter.registerHandler("greeter", async (payload) => ({
  greeting: `Hello, ${payload.handoff?.instruction ?? "World"}!`,
}));

const registry = new AdapterRegistry();
await registry.addAdapter(adapter);
await registry.executeAgent("custom:greeter", {
  action: "greet",
  handoff: { instruction: "World" },
});

Use your existing agent framework. Add discipline where it matters.

If your team already has agent workflows in motion, Network-AI lets you add concurrency control, permission boundaries, and auditability without rewriting the stack from scratch.

Read quick start Integration guide