WHAT CHANGED IN v3
Version 1 established the organizational architecture — the loops, the agent design methodology, the scorecard, the decision framework.
Version 2 added the execution layer — Lean Manufacturing adapted for agentic workflows, the Three Engineering Disciplines, the Six-Layer Deployment Stack, and the Three AIOS KPIs.
Version 3 does three things:
The Universal Loop is renamed: OBSERVE → DECIDE → EXECUTE → IMPROVE.
Everything from v1 and v2 remains. v3 is additive.
THE PREMISE
Your Org Chart Is a Fossil
Here's what nobody in the AI space wants to say out loud: your org chart is a fossil.
Not because you designed it badly. You designed it brilliantly — for a constraint that just stopped existing.
Your organization was never designed around work. It was designed around the staggering cost of moving information between human heads.
Think about it. Why do you hold a Monday standup? Not because work happens there — work stops for standups. You hold it because your people accumulate information all week — decisions made, blockers hit, priorities shifted — and there's no automatic mechanism for that information to flow between them. The standup is the pump. You're manually forcing the transfer because human brains can't sync any other way.
Why do you have a Sales Manager whose primary job is to sit between the CRM and the VP of Revenue? Not because that person sells anything. They translate, consolidate, and relay information from one layer of the organization to another. They exist because those layers can't talk to each other directly.
Why does your organization run weekly syncs, quarterly reviews, status updates, progress reports, email threads, dashboards built to surface information that already exists somewhere — just in a format no one else can read? Same reason. All of it: the pump.
For the entire history of organizational design — from Frederick Taylor's scientific management to EOS to OKRs — the answer to this problem has been the same: build better structures to manage the cost of human information transfer. Better meetings. Better reporting formats. Better org charts. Better communication tools.
Every generation has optimized the pump.
The pump is now obsolete.
Here's the honest version: agents don't share context perfectly — they share it deliberately. When an agent completes a task, it produces a structured output — documented, searchable, versioned — that the next agent hydrates from. The handoff is designed, not accidental. The context that moves is explicit, not tacit. The transfer is auditable, not lossy. This is fundamentally different from how information moves between humans, where context degrades through interpretation, selective memory, and the limits of human speech.
The overhead layer — the 30-40% of a knowledge worker's time spent in meetings, on status updates, in hand-off theater — is not an inefficiency to optimize. It is a structural artifact of a constraint that is, for the first time in history, solvable by design.
The right response is not to make the meetings shorter. It is to eliminate the condition that made them necessary.
Every org chart, every reporting structure, every weekly sync you've ever sat through — all of it was built to solve a problem AI doesn't have. The question isn't whether to reorganize. It's whether you'll figure this out before someone building from scratch eats your market.
This is not incremental improvement. This is architectural replacement.
And here is where most organizations get it completely wrong.
The dominant frame for AI in business is headcount reduction. Fewer humans doing the same tasks at lower cost. That frame is not just incomplete — it's actively harmful. It makes organizations defensive. It makes employees hostile. It makes leaders optimize for the wrong thing.
The right frame is force multiplication.
A single founder with a NexusAOS deployment doesn't do the work of ten people. They do the work of a company — with a fully staffed operation running 24 hours a day, executing dozens of workflows simultaneously, with complete audit trails and zero information loss between shifts. They didn't get cost savings. They got an army.
This reframe matters because it changes every decision that follows:
The agentic organization is not a leaner version of the human organization. It is a different kind of organization — one where a small team of humans with high judgment leads a large workforce of agents with high throughput. The humans don't disappear. They move up. They become architects, strategists, and governors of systems that do things no team their size could do before.
You didn't get cost savings. You got an army.
Everything in NexusAOS flows from this premise.
PART 1: THE 90-DAY TRANSITION PROTOCOL
The Problem with Greenfield Thinking
Most AI frameworks assume you're building from scratch. They give you the ideal architecture and leave you to figure out how to get there from where you are.
You are not starting from scratch. You have existing roles. Existing people. Existing processes. Existing revenue. The lights are on while you're rewiring it.
The biggest mistake in AI transformation: mapping AI to existing roles. "We have a Marketing Manager — let's build a Marketing Manager AI." This preserves every inefficiency baked into that role. It automates the constraint structure. It builds a faster horse.
Roles were designed for humans. They bundle dozens of discrete workflows into one job description because a human can only be hired once. They include enormous amounts of information-gathering and transfer work that exists only because the previous human couldn't pass context to the next one. They reflect the org chart, which reflects the reporting structure, which reflects the information flow constraints of a human organization.
The alternative: Map roles to their constituent workflows. Define the ideal outcomes those workflows must produce. Design agentic workflows backward from the ideal outcome. Deploy.
Here is the protocol. Week by week. With deliverables.
Weeks 1–2: The Workflow Audit
What you do:
For every role in the organization (or the department you're starting with), break it into its constituent workflows.
A role is a container for workflows. The "Marketing Manager" role might contain: campaign planning, copywriting, performance reporting, vendor coordination, social scheduling, email management, SEO monitoring, ad trafficking, meeting coordination, competitive monitoring. Each is a discrete workflow. The role bundles them into one job description because that's how humans get hired.
For each workflow, build your Workflow Registry — a running document with these columns:
| Column | Question It Answers |
|---|---|
| Trigger | What input starts this workflow? |
| Owner | Who currently runs it? |
| Inputs Required | What information must exist before it can run? |
| Output Produced | What does it produce when done? |
| Downstream Consumer | Who or what uses the output? |
| Frequency | How often does it run? |
| Time Cost | Hours per week to execute? |
| **Information Cost** | Hours per week spent explaining, translating, or routing this workflow's outputs to others? |
The Information Cost column is the gold. Any workflow where humans spend more time explaining outputs than producing them is pure Muda — waste that exists only because of the constraint the premise describes. These are your highest-priority automation candidates, and they will be immediately obvious.
Deliverable: Workflow Registry — complete inventory of every workflow in scope.
Weeks 3–4: Outcome Mapping
What you do:
For every workflow in the Registry, answer one question: "If this workflow disappeared tomorrow but the business outcome it produces still happened, would anyone notice the difference?"
This is the critical distinction between output and outcome. Output is what the workflow produces. Outcome is what the output achieves.
A weekly performance report is an output. A founder who makes better decisions faster because they have the right information is an outcome.
The Klarna warning: Klarna's AI customer service produced exactly the right outputs — fast resolution, low cost per ticket — while destroying the actual outcome: customer trust and retention. Nobody specified the outcome. Nobody defined what must never be sacrificed for efficiency. The AI optimized for what was measurable, and optimized away what wasn't.
Every workflow that touches a human relationship, a client interaction, or a trust-sensitive process requires explicit outcome protection. This becomes the Intent Schema for any agent you build to run it.
Deliverable: Outcome Map — every workflow tagged as:
Weeks 5–8: Agent Design Sprints
What you do:
Take 3-5 workflows tagged AUTOMATE. For each, run a design sprint:
The parallel run is non-negotiable. You do not deploy an agent in production without two weeks of shadow running against a human baseline. The parallel run is also your first Kaizen baseline.
Deliverable: 3-5 deployed agents with documented performance data. First real-world proof that the methodology works.
Weeks 9–12: Governance Scaffolding
What you do:
Stand up the Coordination Layer for your pilot agents:
Deliverable: Governance dashboard. Human oversight rhythm established. The Board has visibility into everything the agents are doing.
Exit Criteria:
At least one workflow running fully autonomous with documented improvement in outcome metrics and zero trust violations for 30 consecutive days.
That's the bar. Not "agents are running." Not "we deployed something." One workflow. Documented outcomes. Thirty days of trust.
When you hit that bar, you have proof. Then you scale.
PART 2: THE ARCHITECTURE
Three Layers
NexusAOS organizations have three distinct layers. Each has a different function, a different cadence, a different human-to-agent ratio.
┌──────────────────────────────────────────────────────────────┐
│ THE BOARD │
│ (Human Governance Layer) │
│ │
│ Sets mission. Approves strategy. Controls budgets. │
│ Can pause, override, or terminate anything. │
│ Reviews Guardian Loop alerts. You are the Board. │
│ │
├──────────────────────────────────────────────────────────────┤
│ THE COORDINATION LAYER │
│ (Agent Management and Orchestration) │
│ │
│ Org chart. Heartbeats. Task routing. Budget enforcement. │
│ Governance gates. Audit log. Supervisor protocol. │
│ Cross-agent communication. Concurrency management. │
│ │
├──────────────────────────────────────────────────────────────┤
│ THE WORKFORCE │
│ (Agents doing actual work) │
│ │
│ Running workflows. Executing tasks. Producing Artifacts. │
│ Reporting upward. Operating 24/7. │
│ │
└──────────────────────────────────────────────────────────────┘
The Board
The Board is the human governance layer. In early NexusAOS deployments, this is typically one person — the founder.
The Board does not run the business. The Board governs the system that runs the business.
This distinction is everything. Founders who can't make this shift stay in the loop for every decision, defeating the purpose of the system entirely. You are not an operator anymore. You are the Board.
Board responsibilities:
Set the company mission. The mission is the root node of every delegation in the system. Every task every agent executes traces back to it. The Board sets it, communicates it, and updates it when strategy changes.
Approve agent strategy. When the CEO agent produces a strategic breakdown — how the mission will be executed, which initiatives to pursue, which agents to hire — this proposal requires Board approval before execution begins.
Control budgets. The Board sets top-level resource allocation. Budget cascades through the Coordination Layer. The Board can override any budget at any level, at any time.
Govern agent hires. New agents require Board approval. The Board reviews the Agent Brief, challenges the design, and signs off before the agent runs in production.
Exercise override authority. Pause any agent. Override any decision. Reassign any task. Reprioritize anything. This is not an emergency mechanism — it is the ongoing control surface.
Review Guardian Loop outputs. The Guardian Loop works for the Board. Intent drift flags, anomaly alerts, cost spikes — these land on the Board's desk.
What the Board does NOT do: Fill in for failing agents. Manually execute tasks. Become the dependency that defeats the system's purpose.
The Coordination Layer
The Coordination Layer is the management system — the infrastructure that makes a collection of agents into an organization.
An agent workforce without coordination produces chaos. Concurrent tasks collide. Budgets run away at 3am. Context vanishes between sessions. No agent knows what any other agent did last. The Coordination Layer is what prevents this.
Org Chart and Delegation
Every agent has a position: name, title, role, reporting relationship (who they answer to), and reports (who answers to them). The org chart is not bureaucracy — it is routing. It determines who gets tasks, whose approval is required for what, and how escalations travel.
BOARD (Human)
│
┌────────┴────────┐
CEO Agent Guardian Agent
│
┌────┴─────┬──────────┐
COO CTO CMO
│ │ │
Ops Engineers Content
Agents Agents Agents
Heartbeats
Agents are stateless — they don't run continuously, they run when woken. The Coordination Layer manages the wakeup schedule.
Two modes, both valid, designed for different agent runtimes:
Both modes are supported. Runtime agnosticism means the Coordination Layer adapts to how the agent works, not the reverse.
Task and Ticket System
Every piece of work is a ticket. Every ticket has: an owner, a status, a priority, a thread of communications, and a full audit trace of every action taken against it.
The ticket state machine — valid transitions only:
OPEN → IN_PROGRESS → IN_REVIEW → DONE
↓ ↓
BLOCKED REJECTED → IN_PROGRESS
↓
ESCALATED → [Board review] → IN_PROGRESS or CANCELLED
No ticket moves backward without explicit Board or supervisor authorization. No ticket is silently abandoned. Dead tickets surface as escalations.
When you (the Board) create a task, it enters the ticket system and routes to the appropriate agent. Every tool call, every decision, every intermediate output logs to that ticket — immutable, append-only. This is how oversight scales: 20 Human Review Summaries reviewed in five minutes, deep dives only on flagged items.
Budget Enforcement
Every agent has a resource budget set by the Board, enforced by the Coordination Layer.
Budget enforcement is atomic with task checkout. An agent cannot begin a task if it has hit its budget limit. There is no race condition — checking happens at the checkout gate, before work begins. When an agent hits its limit: hard auto-pause. No more work. The Board is notified. Budget resets or Board manually overrides.
The Supervisor Protocol
Every agent in the NexusAOS system has an assigned supervisor — either another agent or the Coordination Layer itself. The supervisor has three responsibilities:
Liveness monitoring: The supervisor tracks agent heartbeat responses. After N consecutive missed heartbeats (defined in the Agent Brief), the supervisor escalates: first to the next level in the org chart, ultimately to the Board if unresolved. A dead agent gets its open tickets reassigned, not abandoned.
Output validation: The supervisor can reject an agent's output and require retry or escalation. Rejection is a first-class workflow state, not an exception. If an agent returns output that fails its jidoka gate, the supervisor decides: retry (with different parameters), escalate (to human review), or degrade (mark as low-confidence, allow downstream agent to proceed with caveat).
Graceful degradation: When an agent consistently underperforms or cannot be reached, the supervisor can: reassign its work queue to another agent, spawn a replacement, flag for Board review, or downgrade the agent's authority level pending investigation.
The Supervisor Protocol is what makes the Guardian Loop actionable. The Guardian Loop surfaces problems. The Supervisor Protocol handles them.
Governance Gates
Certain actions require Board approval before execution: new agent hires and CEO strategy approval at minimum. The Board can add gates at any level — high-stakes client communications, financial commitments above a threshold, strategy changes above a defined magnitude.
The agent proposes. The proposal lands in the Board's review queue. The Board approves or rejects. Execution begins only on approval.
Runtime Agnosticism
The minimum requirement to be a NexusAOS agent: be callable.
If the Coordination Layer can send you a signal — heartbeat, task assignment, wakeup — you are hireable. OpenClaw bots, Claude Code sessions, Codex agents, Python scripts, HTTP webhooks, shell commands. All first-class agents under the same coordination structure.
The Coordination Layer manages them all through the same interface. You choose the right runtime for each role.
The Workforce
Agents execute workflows, produce Artifacts, delegate subtasks, and report upward. Every agent has:
Full workforce design is in v1 and v2. Unchanged in v3.
The Universal Loop: OBSERVE → DECIDE → EXECUTE → IMPROVE
Everything in NexusAOS runs on one pattern. Four phases. Always the same. Repeating at every level and timescale.
┌──────────────────────────────────────────────────────────────────┐
│ │
│ OBSERVE → DECIDE → EXECUTE → IMPROVE │
│ │
│ Surface what Make a Take it Get visibly │
│ is true now choice to done better │
│ │
└──────────────────────────────────────────────────────────────────┘
Why these words, not the previous ones:
OBSERVE — not "sense." Sensing is passive. Observation is active, directed, purposeful. The agent doesn't wait for inputs — it goes looking for what's true.
DECIDE — unchanged. A choice is made. This is where authority levels do their work — what the agent can decide alone versus what requires escalation to its supervisor or the Board.
EXECUTE — not "act." Act is flat. Execute implies commitment, completeness, and delivery all the way to stated output — not starting the task, finishing it.
IMPROVE — not "learn." Learning is internal and invisible. Improvement is external and measurable — the Kaizen Protocol runs, the Workflow Genome updates, the performance baseline shifts upward. This is the Kaizen cycle embedded in the loop.
The loop at five nested levels:
| Loop | Cadence | Owner | OBSERVE | DECIDE | EXECUTE | IMPROVE |
|---|---|---|---|---|---|---|
| **Nexus** | Annual | Board | Business environment, competitive position | Strategic direction, mission update | Structural changes, new initiatives | Annual retrospective |
| **Strategy** | Quarterly | Board + CEO Agent | Performance vs. targets, market shifts | Priority changes, Sprint configuration | Sprint launches, project initiations | Quarterly Kaizen review |
| **Operations** | Weekly | Operations agents + Board review | Agent performance, workflow metrics, blockers | Issue resolution, priority adjustments | Corrective actions, reconfigurations | Weekly baseline update |
| **Execution** | Continuous | Workforce agents | Incoming tasks, queue state, context | Task selection, approach, escalation trigger | Workflow execution, Artifact production | Per-task Kaizen flag |
| **Guardian** | Always-on | Guardian Agent | Anomalies, cost spikes, intent drift, liveness | Alert priority, escalation routing | Notifications, auto-pauses | Alert threshold refinement |
The loops are nested. The Guardian Loop monitors the Execution Loop. The Operations Loop monitors the Execution Loop's aggregate output. The Strategy Loop reviews Operations. The Nexus Loop frames everything.
PART 3: AGENT DESIGN
(Full content in NEXUS-AOS-v2.md — unchanged in v3)
The Agent Brief: One-page specification required before any agent runs in production. Mission, inputs, outputs, authority level, jidoka gate, context budget, spawn points, artifact spec, intent schema (supervised and above).
Authority Levels:
AUTONOMOUS — Executes and delivers. No review required.
SUPERVISED — Executes and delivers. Human reviews before downstream action.
ADVISED — Produces recommendations. Human decides and acts.
RESTRICTED — Explicit per-task authorization required.
Authority levels are earned through demonstrated performance, never granted by default. Changes require Board approval.
Hydration / Dehydration: Agents are stateless. The Coordination Layer hydrates them (loads Context Bundle at task start) and receives dehydration (Agent Artifact at task completion). The baton that never drops.
The Three Engineering Disciplines:
INTENT ENGINEERING ← what the AI wants (values, priorities, protected outcomes)
CONTEXT ENGINEERING ← what the AI knows (information, history, retrieval)
PROMPT ENGINEERING ← what the AI does (instructions, tasks, format)
Intent engineering is the most critical and most neglected. The Klarna failure was an intent engineering failure. Full Intent Schema template in v2.
PART 4: WORKFLOW EXECUTION
(Full content in NEXUS-AOS-v2.md — unchanged in v3)
The Lean Execution Layer — five Toyota Production System principles adapted for agentic workflows:
The Agentic Vocabulary — novel concepts invented for NexusAOS:
| Term | What It Is |
|---|---|
| **Context Budget** | Deliberate allocation of context window space across workflow steps |
| **Agent Lineage** | Complete provenance record — which agent, which model, which step produced what |
| **Workflow Genome** | Complete versioned specification of a workflow — the object Kaizen improves |
| **Spawn Point** | Defined location where an orchestrator creates sub-agents for parallel work |
| **Memory Horizon** | Effective boundary of what an agent can see from workflow history |
| **Agent Artifact** | Structured hand-off package: output + action log + decision trace + human review summary + jidoka flags |
| **Fleet Orchestration** | Lateral coordination of peer agents working in parallel on the same problem domain |
| **Intent Drift** | Agent behavior that complies with instructions but violates declared intent |
PART 5: DEPLOYMENT
(Full content in NEXUS-AOS-v2.md Part 4 — unchanged in v3)
NexusAOS is not installed. It is grown.
Layer 6 — BUILD Apply freed bandwidth to growth
Layer 5 — AUTOMATE Systematic elimination of repetitive task load
Layer 4 — DAILY BRIEF Synthesized intelligence delivered before the day starts
Layer 3 — INTELLIGENCE Everything that happens, captured and queryable
Layer 2 — DATA OS Live business metrics, agent-accessible
Layer 1 — CONTEXT System knowledge of the business — who you are, what you sell, what you want
The rule: Layers, not leaps. Complexity introduced before the foundation is solid produces fragile systems.
PART 6: GOVERNANCE AND MEASUREMENT
(Full content in NEXUS-AOS-v2.md Part 5 — unchanged in v3)
Three AIOS KPIs:
| KPI | Definition | 90-Day Target |
|---|---|---|
| **Away-from-Desk Autonomy** | % of normal workload executable from mobile without your primary workstation | 90%+ |
| **Task Automation %** | % of Workflow Registry entries automated or heavily augmented | 60–70% |
| **Revenue Per Employee** | Annual revenue / total headcount including founder | Rising quarter-over-quarter |
The business case for every NexusAOS client is one diagram: from 80% in-the-business / 20% on-the-business → to 15% in / 85% on.
The Guardian Loop monitors always-on: cost anomalies, jidoka failure rates, intent drift (flagged for Board — not auto-resolved), security boundary violations, agent liveness. Its output is always flags, not fixes. The Supervisor Protocol handles the fixes.
The Kaizen Protocol governs every configuration change. The Workflow Genome is the object it improves. Baseline → Hypothesize → Test → Measure → Adopt or Discard. If you can't measure the improvement, you don't have a kaizen — you have a guess.
PART 7: THE AGENTIC INFORMATION ARCHITECTURE
What Replaces the Overhead Layer
The Premise established what the overhead layer was for. Here is what replaces it.
| Legacy Structure | Why It Existed | What Replaces It |
|---|---|---|
| Monday standup | No automatic mechanism for team information to flow | Coordination Layer: real-time status visibility to all authorized agents and Board |
| Hand-off meeting | Context transfer from one human to the next | Agent Artifact: complete, structured hand-off produced at task completion, consumed at hydration |
| Weekly sync | Calibrate priorities, surface blockers across teams | Operations Loop: automatic weekly performance review, alert surfacing, priority adjustment |
| Morning standup | Surface what happened yesterday | Daily Brief: synthesized overnight report, delivered before the workday starts, zero meeting |
| Status update email | Inform stakeholders of progress | Guardian Loop anomaly report + Agent Artifact human review summary |
| Quarterly review | Assess performance, set priorities | Strategy Loop: Board reviews Operations Loop aggregate, sets next quarter configuration |
What remains human: Every structure that exists not to transfer information but to exercise judgment — strategy decisions, relationship-building, creative direction, ethical review, high-stakes client interactions. The overhead disappears. The judgment stays.
The test for every meeting on your calendar:
Does this meeting exist because humans need to exchange information that could flow automatically? Or because a human judgment call needs to be made?
Information exchange → replace with an agentic information flow.
Human judgment → keep. And make it shorter, because participants now arrive fully briefed by agents who did the synthesis overnight.
PART 8: THE HUMAN SIDE OF THE TRANSITION
What Nobody Else Will Tell You
The transition to an agentic organization is a technology problem for about 30% of its difficulty. The other 70% is human.
Start here: this is not a headcount reduction exercise. Organizations that frame AI deployment as "doing the same work with fewer people" will fail — not because the technology doesn't work, but because they've given every person in their organization a reason to resist it. Nobody fights for an outcome that eliminates them.
The right frame — the honest frame — is force multiplication. The goal is not to shrink the team. The goal is to dramatically expand what the team can accomplish. A 10-person company operating with NexusAOS doesn't do the work of 8 people at lower cost. It does the work of 50 — with better documentation, faster execution, and complete accountability at every step.
When you lead with this frame, the entire change management problem shifts. You're not taking work away. You're giving people leverage they've never had.
Some roles become dramatically different. Some become smaller. Some disappear. The people in those roles are not infrastructure — they're humans who built their identity and livelihood around the work they do. Treating this as purely an efficiency calculation is how you generate resistance that kills the deployment.
The three categories of people in the transition:
Architects — The people who design workflows, write agent specs, and set intent schemas. These roles grow in importance. Every agent needs a human who understands what it's supposed to do and can evaluate whether it's doing it. The specification skill — turning vague outcomes into precise, testable agent instructions — is one of the most valuable skills in the agentic era. People who develop it become disproportionately powerful.
Governors — The people who monitor, review Artifacts, catch intent drift, and maintain the Guardian Loop. These roles don't disappear — they change. The best operators and analysts become governors: responsible for the quality of what agents produce rather than the production itself.
People whose roles contained primarily information transfer work — This is the hardest category. If someone's primary value was synthesizing and routing information that agents now route automatically, the work they were hired to do may genuinely no longer exist. Honest acknowledgment of this — and genuine effort to find where those people's other capabilities translate — is not optional. Organizations that skip this step face the kind of human resistance that turns good technology into failed deployments.
The change management principle:
Every person whose role is affected by the transition should be involved in the Workflow Audit that maps it. The people doing the work understand it better than anyone. Their participation in mapping it creates ownership of the outcome rather than resentment of the change. They become architects of their own transition, not its victims.
THE INNOVATIONS OF NEXUSAOS v3
What this framework contributes that exists nowhere else
| Innovation | Layer | Version |
|---|---|---|
| **The Premise** — human org design as information cost management | Architecture | v3 |
| **90-Day Transition Protocol** — week-by-week methodology with deliverables and exit criteria | Deployment | v3 |
| **The Coordination Layer** — explicit architecture for agent governance | Architecture | v3 |
| **The Board framing** — human as governance layer, not supervisor or operator | Architecture | v3 |
| **The Supervisor Protocol** — liveness, output validation, graceful degradation | Operations | v3 |
| **Ticket State Machine** — formal status transitions for task governance | Operations | v3 |
| **The Human Side** — change management framework for the transition | Deployment | v3 |
| **Agentic Information Architecture** — what replaces each legacy meeting structure | Architecture | v3 |
| OBSERVE → DECIDE → EXECUTE → IMPROVE | Architecture | v3 (renamed from v1) |
| Three Engineering Disciplines | Design | v2 |
| Intent Schema | Design | v2 |
| Intent Drift Detection | Guardian | v2 |
| Jidoka / Kanban / Kaizen / Value Stream / Muda | Execution | v2 |
| Context Budget / Agent Lineage / Workflow Genome / Spawn Points / Memory Horizon | Execution | v2 |
| Agent Artifact Standard | Execution | v2 |
| Fleet Orchestration | Execution | v2 |
| Six-Layer Deployment Stack | Deployment | v2 |
| Three AIOS KPIs | Measurement | v2 |
| Five Nested Loops | Architecture | v1 |
| Authority Level progression | Design | v1 |
| Hydration / Dehydration | Design | v1 |
NexusAOS v3.0
By St. Clair Newbern IV
March 2026
This framework is a living document. Every deployment teaches it something. Every critique sharpens it. Every practitioner who implements it and reports back makes it more real.
Contributions and challenges welcome.