The runtime is layered. A typed neuro substrate at the bottom; a four-tier hierarchy on top. Brain orchestration, five-layer memory, meeting rooms, schedules, agent-to-agent talk, voice — all wired through a single shared runtime.
Agency wraps Project wraps Agent wraps Neuro. Each layer adds scope; none change the model. The neuro at the bottom is the same atomic unit whether it's running standalone or inside a meeting room of agents.
Top-level workspace — a team. Color, emoji, set of agents, default project. Shipped: Neuro HQ, Upwork, Web Agency.
Unit of work inside an agency. Default project ships with every agency. Boundaries for memory and conversations.
Role-specialised orchestrator with router + planner + replier + profile. Shipped: neuro, nl_dev, opencode, openclaw, upwork.
The atomic unit. conf.json + code.py + optional prompt.txt. Hot-loadable.
The brain implements a ReAct loop. Every message is classified by the smart router. Conversational ones get answered immediately. Skill-needing ones go through the planner, executor, and reply.
One LLM call to classify intent. Direct reply, or skill execution? If a skill is needed, identify which one and pass to the planner. Simple questions get answered instantly.
For multi-step requests, the planner breaks the goal into a Directed Acyclic Graph of skill calls. Each node is one neuro invocation; outputs flow into later inputs.
Walks the graph node by node. Handles errors, retries, hooks. Captures node.log events. Streams progress over WebSocket.
The flow engine supports four composition strategies, all available as neuros. Categorical morphism composition under the hood — the laws (associativity, identity) hold.
core/flows/sequential_flow.py — A | B | C. The default. Output of A feeds B, output of B feeds C.
core/flows/parallel_flow.py — A & B. Both run concurrently via asyncio.gather; outputs combine.
core/flows/dag_flow.py — Multi-path with conditions and parallel branches. Supports loops, human-gates, sub-graphs.
core/tool_loop_neuro.py — Iterative: a neuro calls tools in-reply, observes, continues. Bounded, depth-guarded.
A graph-first substrate with a 5-layer query pattern. Cheap always-loaded footprint; deep recall on demand. LLM-maintained taxonomy — categories grow with the data, not from a hardcoded list.
Core agent identity + user identity. Hand-authored. Always loaded.
Top-priority facts in compressed form. Refreshed nightly by an LLM librarian.
Categories: wings / rooms / halls. Names + one-line definitions. Always-loaded as an index.
Structured facts in temporal KG + embedding. Loaded on topic relevance via PPR + vector hybrid retrieval.
Verbatim source — the existing conversations/*.json. Loaded on explicit deep-dive only. Never destructively summarised.
valid_to; create new edge.Three primitives compose every multi-agent pattern: a typed talk primitive, persistent meeting rooms with mediation, and time-aware triggers (next section).
An isolated real-time collaboration space. Multiple agents share a transcript. A mediator picks the next speaker round-robin. Backed by core/rooms.py and core/rooms_db.py with four neuros: room_create, room_post, room_close, room_mediator.
UI surface: neuro_web/components/rooms/RoomPanel.tsx. Endpoint: /api/rooms.
agent.talk(target, msg)An abstract primitive for direct typed messages between agents. Depth-guarded — MAX=4 via TalkDepthExceeded — to prevent infinite loops. Two neuros: agent_talk, agent_list.
This is the substrate beneath rooms, and the seed of categorical mailbox protocols where deadlock and starvation are analysable from types.
Cron-style triggers persisted to schedules.db via APScheduler. The user says "every morning at 8 send me the summary" — the runtime takes it from there.
schedule_runCreate a trigger. Accepts natural-language time expressions (parsed by core/trigger_parse.py) or cron strings.
schedule_listList all active triggers. Inspect what's scheduled and when.
schedule_cancelCancel by trigger ID. Cleanly removes from DB and APScheduler.
# Persistence
core/schedules_db.py # SQLite store
core/scheduler.py # APScheduler glue
core/trigger_parse.py # NL → cron
# API
GET /api/schedules
POST /api/schedulesAll audio travels through LiveKit — the same transport used for the desktop video stream. Single connection, low latency.
Microphone
↓
Silero VAD # voice activity detection
↓
Sarvam Streaming STT # speech-to-text
↓
Brain # LLM reasoning + skill execution
↓
ElevenLabs TTS # text-to-speech
↓
SpeakerIn NeuroLang terms, voice is just an effect: effect="voice". The standard library wires LiveKit, Twilio/Plivo, ElevenLabs, OpenAI TTS, Whisper, Deepgram, Sarvam — adapters, not magic.
PNP Compute is designed to run inside a private, isolated machine — a dedicated workstation, a VM, or a container separate from your personal host OS.
Autonomous agents need access to your screen, files, and inputs. By isolating this to a dedicated environment, you control exactly what they can see and touch. This is the recommended deployment model.
The system is designed for single-user, long-lived deployment. No multi-tenancy. Memory is yours. Conversations are yours. Files are yours.
A focused REST + WebSocket surface. Conversations, agents, profiles, rooms, schedules, mouse, keyboard, streaming.
| Method | Endpoint | Purpose |
|---|---|---|
POST | /chat | Send a message to the active agent |
GET | /agents | List all running agents |
POST | /agents/{type} | Switch to a specific agent type |
GET | /api/profile/list | List all profiles |
GET | /api/profile/active | Get active profile |
POST | /api/profile/switch | Switch profile |
GET · POST | /api/rooms | List · create a meeting room |
GET · POST | /api/schedules | List · create a scheduled trigger |
POST | /stream/start | Begin desktop screen streaming |
GET | /voice/token | Get LiveKit token for voice sessions |
POST | /mouse/move · /click · /scroll | Mouse control |
POST | /keyboard/send | Keystrokes and key combos |
Full endpoint details in GitHub · coming soon.