NANO Agent Stack
Modular orchestration infrastructure for agent systems that need structure, auditability, and real operational topology.
NANO Agent Stack is an open-source ecosystem for modeling departments, hierarchies, skills, policies, memory boundaries, trace hooks, approval gates, SQLite-backed persistence, and experimental provider seams as explicit infrastructure primitives.
Structure-first
Departments, managers, workers, skills, and policies stay explicit.
Auditability
Runs emit traces, approval decisions, review artifacts, and inspection layers.
Modular ecosystem
Core runtime plus skills, templates, observability, docs, and benchmarks.
Operational topology
Infrastructure seams
Run artifacts
An open-source ecosystem for modular multi-agent orchestration.
NANO is built for builders who need systems that can represent organizational structure and still remain inspectable, composable, and open-source friendly.
Most agent demos hide structure inside prompt chains and wrappers.
That makes them hard to audit, hard to extend, and hard to map onto real workflows. NANO instead models departments, managers, workers, skills, policies, traces, and approval boundaries as explicit runtime seams.
A hierarchy-first runtime for representing organizations as systems.
The design is intentionally narrow: routing, structure, policies, memory boundaries, and traces stay visible instead of disappearing into generic agent abstractions.
Orchestrator
Coordinates task execution, provider strategy, policy enforcement, approvals, and artifact generation.
Departments
Own operational domains like research, content, support, or internal operations.
Managers and workers
Managers decompose work, workers execute through skills and provider-assisted notes.
Skills, memory, traces, approvals
Reusable capabilities, pluggable state boundaries, execution chronology, and gated human review.
Recent work pushed the runtime closer to real operational control.
The current alpha now includes human approval gates that can block execution, SQLite-backed memory, CLI validation, template discovery, a richer run inspector, and experimental provider seams with tested HTTP boundaries.
Approval gates
Checkpointed tasks can now be approved or rejected, and rejection blocks downstream worker execution.
Provider seams
OpenAI Responses and Anthropic Messages are integrated through a shared HTTP provider layer and tested request/response contracts.
SQLite memory
Examples can persist workflow state and approval decisions into a local SQLite store for more durable repeatable runs.
Inspector + benchmark
The ecosystem now includes a richer run inspector and a 2x2 benchmark matrix for workflow shape and approval posture.
From executive intent to department execution and traceable outputs.
NANO models the chain from intent to work packets to artifacts as a visible system. The goal is to make agentic execution feel more like infrastructure architecture than hidden automation.
Control layer
Orchestrator / executive intent
Defines workflow boundaries, enforces policy, chooses provider strategy, and preserves the overall execution trace.
Department layer
Managers coordinate departments
Research, content, support, or internal operations can each own tasks and route them to the right workers.
Execution layer
Workers invoke skills and emit outputs
Skills, tools, memory adapters, and trace hooks turn a workflow into inspectable operational infrastructure.
Policies
Govern run size, approval gates, and fallback behavior.
Memory interfaces
Persist shared state without fusing storage into agent behavior.
Trace hooks
Preserve chronology, actor flow, and review checkpoints.
A focused set of repositories around the core runtime.
Each repository handles a clear layer of the ecosystem, keeping the overall stack modular instead of turning the core into a monolith.
nano-agent-stack
Core runtime for orchestration, policies, providers, memory boundaries, and task execution.
Open repository
nano-agent-skills
Reusable skill registry and starter capability pack.
Open repository
nano-agent-templates
Operational templates for research, content, support, marketing, and internal assistants.
Open repository
nano-agent-observability
Trace exports, structured logging, and visual run inspection.
Open repository
nano-agent-docs
Architecture, design notes, glossary, and ecosystem-level documentation.
Open repository
Patterns designed for workflows that resemble teams, not toy prompts.
The current examples and templates focus on operational scenarios where structure, routing, and review boundaries matter.
Support NANO Agent Stack
If this project is useful to you, or if you want to support more open-source work around agent orchestration, observability, and developer-grade AI infrastructure, you can contribute directly.
Input becomes a routed workflow, then a department execution chain.
A typical run starts with one intent, routes through a manager layer, fans out to workers and skills, and returns a reviewable artifact plus trace.
1. Input
A request enters the orchestrator with a desired output and policy boundaries.
2. Routing
The task is assigned to a department manager who owns the workflow domain.
3. Approval gate
If a checkpoint is configured, a reviewer can approve or reject execution before workers proceed.
4. Execution + result
Approved runs invoke skills and provider-assisted notes, then emit markdown, JSON trace data, approvals, and visual inspection artifacts.
npm install
npm run demo
npm run demo:content
npm run demo:support
npm run demo:openai
npm run validate:demo
npm run templatesArtifacts
Current demos also capture approval outcomes inside the run report, persist memory into SQLite when configured, and feed a richer HTML inspector for review.
A small but real developer path from install to demo run.
The goal is not a fake landing page. The GitHub repo already includes a CLI, executable demos, approval control flags, generated artifacts, tests, and supporting ecosystem packages.
npm install
npm run demo
npm run demo:content
npm run demo:support
npm run demo:openai
npm run validate:demo
npm run templatesThe ecosystem now exposes both structural scores and historical runtime traces.
`nano-agent-bench` now combines a structural comparison matrix with runtime-backed department executions from the core orchestrator. `nano-agent-observability` can also archive multiple runs into a simple historical record for later inspection.
Benchmark matrix
fastest path, weakest governance
more reviewable, still structurally shallow
better decomposition and traceability
strongest governance and audit posture
Historical artifacts
A staged path from alpha runtime to broader public beta.
The roadmap stays narrow and honest: stronger provider boundaries, richer persistent memory, distributed execution control, and better observability without pretending the stack is already production-complete.
Agent systems become more trustworthy when their structure stays visible.
Builders need more than a single prompt wrapper. They need the ability to represent authority, decomposition, traceability, and human review as composable system parts. That is the space NANO is aiming at.