Agent-Native Organizations in Practice: Lessons from Macrohard's Stall and MSR Research's Deployed ANO

1. Introduction

The thesis is simple: if AI agents can write code, analyze data, manage projects, generate content, handle compliance, and coordinate with each other, then organizations can be restructured around agent capabilities rather than human headcount. The agents become the workers. Humans become stakeholders, supervisors, and exception handlers.

This is not a new idea. Multi-agent systems have been studied since the 1980s (Ferber, 1999). What changed in 2025–2026 is the confluence of three developments:

1. Model capability: Large language models (Claude, GPT-4, Grok-3) reached the competence threshold for sustained autonomous work — not just answering questions, but executing multi-step tasks with tool use, file manipulation, and API interaction.

2. Agent frameworks: Tool-use protocols (Anthropic's tool_use, OpenAI's function calling), agent SDKs, and MCP (Model Context Protocol) standardized the interface between agents and their environments.

3. Economic pressure: The cost of human knowledge work continued rising while the cost of AI inference continued falling, creating the economic conditions for organizations to explore agent-first structures.

Two organizations attempted this in 2025–2026, with radically different approaches:

This paper documents what each built, why one stalled, and what the other learned. We propose a maturity model for ANO development and argue that the progression through it cannot be skipped.

2. Background: The Macrohard Experiment

2.1 Origins

xAI was founded in July 2023 by Elon Musk with twelve co-founders drawn from Google DeepMind, Microsoft, and other leading AI laboratories (Fortune, 2026). Its flagship product, Grok, is a large language model integrated into X (formerly Twitter). By early 2026, xAI had achieved a $250 billion valuation through SpaceX's all-stock acquisition (CNBC, 2026) and received a $2 billion investment from Tesla (Seeking Alpha, 2026).

Macrohard emerged from this infrastructure. On August 23, 2025, Musk posted on X:

"Join @xAI and help build a purely AI software company called Macrohard. It's a tongue-in-cheek name, but the project is very real! In principle, given that software companies like Microsoft do not themselves manufacture any physical hardware, it should be possible to simulate [them entirely with AI]."

The name — a deliberate inversion of "Microsoft" — captured attention. xAI filed a U.S. trademark application for "MACROHARD" on August 1, 2025 (Windows Central, 2025).

2.2 Architecture

At a public all-hands meeting on February 11, 2026, Musk restructured xAI into four divisions: Grok (chatbot), Coding (AI coding tools), Imagine (video generation), and Macrohard (computer-use agents). Toby Pohlen, formerly a staff research engineer at Google DeepMind for six years, led the Macrohard division (Analytics Insight, 2026; TechBriefly, 2026).

Pohlen described Macrohard's goal as "a fully capable, real-time human computer emulator" that is "able to do anything on a computer that a human is able to do, including using advanced tools in engineering and medicine" (Dataconomy, 2026).

The technical architecture centered on:

- GUI-centric computer use: Agents observe screens, read interfaces, click buttons, and type text — operating software exactly like humans, without requiring API integrations or vendor cooperation (UC Today, 2025).

- Multi-agent swarms: Hundreds of specialized agents handle coding, testing, UX, content, compliance, and deployment. Multiple agents produce competing solutions; adjudicator agents select optimal variants (WindowsForum, 2025).

- Grok as orchestrator: Grok-3 serves as the "master conductor/navigator" — the strategic reasoning layer directing all agent activity (CNBC, 2026).

- Closed-loop simulation: Virtual environments emulate target operating systems, browsers, and peripherals with synthetic users (WindowsForum, 2025).

2.3 Ambitions

Musk's follow-up post expanded the vision:

"The @xAI MACROHARD project will be profoundly impactful at an immense scale. Our goal is to create a company that can do anything short of manufacturing physical objects directly, but will be able to do so indirectly, much like Apple has other companies manufacture their [products]."

The core thesis: since 80–95% of enterprise software operates through graphical interfaces, building agents at the GUI layer unlocks more business software than API-dependent approaches. Macrohard would not need vendor cooperation — it could operate any software simply by watching and interacting with the screen, the same way a human worker does.

The revenue model projected a freemium tier for document handling, per-seat pricing for professional agents, enterprise private deployments, and a marketplace for third-party agent authors (UC Today, 2025).

Pohlen further claimed: "There should be rocket engines fully designed by AI" (Dataconomy, 2026).

2.4 Timeline of Decline

The timeline tells the story more clearly than any analysis:

Seven of twelve co-founders departed within 2.5 years (Fortune, 2026; TechCrunch, 2026; Silicon Republic, 2026; The Information, 2026). Engineers reported significant culture clash between xAI's academic research orientation and SpaceX's intense operational approach (SatNews, 2026). Musk characterized the departures as "push, not pull" — suggesting employees were encouraged to leave (TechCrunch, 2026).

2.5 Key Failure Signals

Five failure signals are visible from public reporting:

Sherwood News summarized: "Painting 'MACROHARD' on a building isn't the same as following through on the project" (Sherwood News, 2026).

3. The MSR Research ANO: Architecture of a Deployed System

MSR Research has operated as an Agent-Native Organization since early 2026. Unlike Macrohard's announcement-first approach, MSR's ANO was built incrementally through production iteration — each component deployed, tested under real workloads, and hardened before the next was added.

3.1 Organizational Structure

34 agents organized into six functional teams:

Each agent has a celestial-themed name, defined competencies, explicit handoff rules (which agents receive work next), preconditions (required inputs), and postconditions (guaranteed outputs). The full roster is documented in `AGENTS.md` and registered in `backend/app/config/agent_registry.py`.

3.2 Core Principles

MSR's ANO operates under five principles, each backed by deployed infrastructure:

3.3 Technical Infrastructure

The agent messaging system uses a Supabase-backed message queue (`agent_messages` table) with an executor worker that processes directives. Eleven Telegram bots serve as human-agent interfaces:

- Lumen (operations): access to all 34 agents, 88 tools, personal assistant

- SaladBar (development): 10 dev agents

- LaVerne (municipal): 9 grants agents

- Coach/Sage (advisory): policy guidance

- 6 Leadership PA bots: SUMMIT, METRICS, VISTA, APEX, NEXUS, GUARDIAN — scoped to role-specific agents

Access control is enforced per-bot via `bot_agent_access.py` — each bot has an explicit ACL defining which agents it can reach. Lumen has access to all 34; LaVerne has access to 9 grants-focused agents. There is no implicit "all access" except for the designated orchestration channels.

The Claude Executor (Node.js, port 5002) provides isolated workspace execution for agent tasks, triggered by Lumen or the executor worker.

3.4 Safety Systems

Deployed in production (PR #347, 2026-03-10), the safety layer addresses three failure modes documented in the "Agents of Chaos" paper (arXiv:2602.20021):

- `_check_circuit_breaker()` counts messages between any agent pair in a 30-minute sliding window

- Threshold: >5 messages triggers the breaker

- Records to `agent_circuit_breakers` table (8 columns: id, from_agent, to_agent, triggered_at, message_count, resolved_at, resolved_by, metadata)

- Fail-open design: database errors never block legitimate traffic

- Human operator resolves via `POST /api/v1/safety/circuit-breakers/{id}/resolve`

- Scans all directive payloads before Claude API execution

- Four pattern categories: base64 payloads (blocks >20 chars), instruction overrides ("ignore previous," "you are now"), encoded commands (hex sequences, unicode escapes), role injection ("you are a system administrator")

- Flag + escalate; does not hard-block (minimizes false positives)

- ~10ms overhead per message

- Persists to `agent_directive_scans` table

- `GET /api/v1/safety/circuit-breakers` — list active (unresolved) loop events

- `POST /api/v1/safety/circuit-breakers/{id}/resolve` — human acknowledge and unblock

- `GET /api/v1/safety/directive-scans` — flagged scan log

- `GET /api/v1/safety/summary` — dashboard counts (active breakers + flagged scans today)

These are not theoretical. They are deployed to production, running on civic-main, processing real agent traffic.

3.5 Trust Architecture

MSR's trust model operates on a progressive trust principle: agents earn autonomy through consistent performance, they don't start with it.

Trust scores route to four approval tiers:

1. Auto-approve: High-trust agent, low-risk action. No human intervention required.

2. Peer review: Medium-trust or medium-risk. Another agent validates before execution.

3. Committee review: Lower trust or higher risk. Multiple agents or a human supervisor reviews.

4. Human approval: Critical decisions (deployments, financial transactions, external communications). Always requires human sign-off.

Seven enforcement gates apply to every feature, regardless of trust level (`STANDARDS.md`):

3.6 Commercial Model: Blueprint Export

MSR's ANO is not just an internal operating model — it is a product. The Blueprint Export system packages a scoped, rebranded ANO as a deployable ZIP for external organizations:

The Enterprise tier (deployed March 12, 2026) uses `OrgChartExtractorService` to scrape an organization's public website, extract departments and leadership, and generate a fully customized ANO with per-department agents. Each package includes `docker-compose.yml`, agent-readable README with YAML frontmatter, and all secrets scrubbed.

Stripe checkout is live (products `prod_U871k9qiItel2C`, `prod_U87173D1BWpdrp`). R2 storage serves signed download URLs with 7-day expiry.

4. Comparative Analysis: Macrohard vs MSR Research

The contrast is not subtle. Macrohard described an architecture. MSR deployed one.

5. Addressing the Open Questions

Industry analysts, journalists, and enterprise architects raised specific questions about Macrohard's approach. Each question below is followed by MSR Research's deployed answer — not a theoretical proposal, but a reference to running code.

Q1: How do you prevent agent loops?

The design is fail-open: if the database query fails, the message proceeds normally. This prevents safety infrastructure from becoming a single point of failure for legitimate traffic.

Q2: How do you detect prompt injection in agent-to-agent communication?

1. Base64 payloads — blocks >20 characters (potential encoded instructions)

2. Instruction overrides — "ignore previous instructions," "you are now," "new instructions"

3. Encoded commands — hex sequences, unicode escapes

4. Role injection — "you are a system administrator," "act as root"

Flagged directives are logged to `agent_directive_scans` and escalated. They are not hard-blocked (to avoid false positives stopping legitimate work). Overhead: ~10ms per message.

Q3: How do you coordinate dozens of agents without chaos?

- Preconditions: What inputs it requires before starting

- Postconditions: What outputs it guarantees when done

- Handoff rules: Which specific agents receive work next

The message queue (`agent_messages` table) processes directives through an executor worker. Access is controlled per-bot via `bot_agent_access.py` — SaladBar bot can reach 10 dev agents; LaVerne bot can reach 9 grants agents. No bot has implicit access to all agents except Lumen (the operations channel).

Pipeline orchestration follows a stage-based model: each product pipeline (Grants, SaladBar, AI Policy) has a defined processing service that sequences stages, invokes real agent classes, runs parallel stages via `asyncio.gather`, and enforces quality gates (keyword + length + structure scoring).

Q4: How do you maintain quality?

1. Test success (100% pass, ≥80% coverage)

2. File verification (all files exist on filesystem)

3. Branch policy (worktrees + feature branches, never main)

4. Documentation (PRD updated, acceptance criteria checked)

5. Code quality (lint + typecheck + build, zero warnings)

6. Security (no secrets, parameterized queries, RLS policies)

7. User approval (human must approve merge)

For content products, a QC pipeline scores reports on novelty, similarity, and source quality before publication. Feature flags (`qc_pipeline_{product}`) gate each product independently. Pass threshold: 60. All passing reports auto-approve (the former 85 auto-approve threshold was removed 2026-03-21 after it created a delivery black hole for reports scoring 60-84).

Q5: How do you handle agent trust?

1. Auto-approve — high trust, low risk

2. Peer review — medium trust or medium risk

3. Committee — lower trust or high risk

4. Human — critical decisions (deploys, financials, external comms)

Three-tier deployment adds environmental guardrails:

- Development (Mac): All 34 agents, destructive ops allowed

- Test (civic-test): 10 agents, approval required for destructive ops

- Production (civic-main): 4 agents (Forge, Quest, Shield, Schema), destructive ops blocked

Q6: How do you make this commercially viable?

- Developer Pack ($2,500): 5 dev agents, Docker, 6 skills

- Full Municipal Pack ($5,000): + grants agents, Ideas Portal, tunnels

- Enterprise ANO ($10,000–15,000): + org chart extraction, CEO agent, per-department head agents, HR builder, concierge bot

Stripe checkout is live. Products created in live mode. Webhook handles payment → export → R2 storage → signed download URL email. The enterprise tier uses `OrgChartExtractorService` to extract an organization's departments from its public website and generate a fully customized ANO package.

Additionally, MSR generates revenue from its subscription products (AI education, tech scout, political discourse, MSR chronicles), all produced by agent pipelines.

Q7: How do you handle agent failures?

- Ralph Loop (iterative retry): Stop hook detects stalled agents via promise tokens and circuit breaker (hashes last 20 transcript lines, escalates if unchanged across 3+ iterations). Pipeline-specific retries: research tunnels retry up to 3× with keyword broadening; grants retry with broader search prompts; SaladBar retries until quality_score ≥ 0.8.

- Fail-open defaults: Safety infrastructure never blocks legitimate traffic on database errors. Circuit breakers trip on detected loops; they don't trip on infrastructure failure.

- Pipeline stage isolation: Each pipeline stage can fail independently without cascading. Failed stages are retried or escalated; they don't silently pass bad output downstream.

- Quality gates: The QC pipeline catches bad output before publication. Reports scoring below 60 are held for review; all reports scoring 60+ auto-publish.

6. Why GUI-Centric Failed Where API-Native Succeeded

Macrohard's architectural bet was that GUI-centric computer use — agents observing screens and clicking buttons — would unlock more enterprise software than API-based approaches. The logic: 80–95% of enterprise software has GUIs but not APIs. Build agents at the GUI layer and you can operate anything.

This logic has a critical flaw. It optimizes for breadth of access at the cost of reliability of interaction.

The GUI Fragility Problem

GUI agents are inherently brittle. UC Today (2025) drew the parallel to Robotic Process Automation (RPA):

- Screen layout sensitivity: A vendor changes a button position, adds a modal, or reorganizes a menu. The agent breaks.

- Update fragility: Every software update is a potential breaking change for every GUI-based agent.

- Maintenance overhead: RPA created "a cottage industry of maintenance" for edge cases. Vision-language models may be more resilient than pixel-matching, but they still depend on visual consistency that enterprise software does not guarantee.

- Non-determinism: Two identical screens can render differently based on browser, OS version, display scaling, dark mode, or A/B testing. Every rendering variation is a potential failure mode.

The API Alternative

API-native agents interact through structured tool calls:

- Deterministic I/O: Structured requests produce structured responses. No rendering variance.

- Fast: No screen observation latency, no rendering overhead. A tool call completes in milliseconds.

- Composable: Tools can be chained, parallelized, and orchestrated programmatically.

- Versionable: API contracts change less frequently than GUI layouts. When they do change, the change is documented in a changelog, not discovered by a broken screenshot comparison.

- Auditable: Every tool call is logged with inputs and outputs. No ambiguity about what the agent did.

MSR's Proof

MSR's 34 agents operate entirely through structured tool calls and MCP. None of them observe screens. None of them click buttons. They call `POST /api/v1/agent-messages`, they query Supabase via RPC, they use Claude's tool_use interface, they interact with Telegram's Bot API. Every interaction is structured, logged, and reproducible.

The result: zero GUI-related failures. Not because GUI agents can't work — Anthropic's Claude computer-use capability demonstrates they can — but because API-native interaction is more reliable for sustained multi-agent coordination. When you need 34 agents working together continuously, you need the interaction layer to be deterministic, fast, and auditable. GUIs are none of these things at scale.

7. The ANO Maturity Model

Based on MSR Research's experience building a production ANO and analyzing Macrohard's attempted one, we propose a five-level maturity model for agent-native organizations:

The Progression Requirement

Macrohard attempted to jump from Level 0 to Level 4. The project announced an architecture for Level 4 (fully autonomous agent company) without building the infrastructure required at Levels 1–3:

- Level 1 requires: Named agents with defined competencies, basic task routing, human-triggered execution.

- Level 2 requires: Contract-driven handoffs, inter-agent messaging, safety infrastructure (circuit breakers, scanners), progressive trust, quality gates.

- Level 3 requires: Automated exception handling, behavioral baseline monitoring, self-improving agent performance, trust calibration.

MSR Research progressed from Level 0 to Level 2 over months of production iteration. Each level was built on the infrastructure and lessons of the previous one:

- Level 0 → 1: Define agents, assign competencies, build message routing (PR #209, February 2026)

- Level 1 → 2: Add contract-driven handoffs, pipeline orchestration, safety infrastructure, progressive trust (PRs #241, #278, #347, February–March 2026)

The lesson: you cannot skip levels. The safety infrastructure required at Level 2 cannot be designed in the abstract — it must be informed by the failure modes encountered at Level 1. The trust calibration required at Level 3 cannot be implemented without the audit trail built at Level 2. Each level generates the data and experience needed to build the next.

Macrohard's failure was not a failure of ambition. It was a failure of progression. Level 4 is theoretically achievable. But you get there by building through Levels 1–3, not by announcing Level 4 and hoping the infrastructure materializes.

Implications for ANO Practitioners

1. Start at Level 1, not Level 4. Name your agents. Define their competencies. Route tasks manually. Learn what breaks.

2. Build safety at Level 2, not after Level 4. Circuit breakers, directive scanners, audit trails — these must exist before agents coordinate autonomously.

3. Earn trust progressively. Trust scores should start low and increase based on demonstrated performance. Never assume full trust at deployment.

4. Use contracts, not vibes. Every agent handoff should have explicit preconditions, postconditions, and routing rules. "The swarm will figure it out" is not an architecture.

5. API-native first. GUI-based interaction is appropriate for specific use cases (testing, accessibility). It is not appropriate as the primary interaction layer for multi-agent systems.

8. Implications for Practitioners

Beyond the maturity model, several practical lessons emerge from the Macrohard/MSR comparison:

Safety infrastructure is a prerequisite, not a Phase 2

Macrohard announced no safety infrastructure. MSR deployed circuit breakers, directive scanners, and a safety API before expanding agent autonomy. The order matters. You cannot safely expand agent capabilities without mechanisms to detect and halt failure modes.

The analogy is software development itself: you write tests before shipping to production, not after. You add monitoring before scaling, not after. Safety infrastructure follows the same pattern — it must precede capability expansion, not follow it.

Human-in-the-loop is not a weakness

Macrohard's pitch — "purely AI software company" — treated human involvement as a limitation to overcome. MSR's experience shows the opposite: human oversight is what makes agent autonomy safe. The four operational modes (Observer, Copilot, Operator, Night-Run) allow the level of human involvement to be tuned based on trust, risk, and maturity.

Gate 7 (User Approval) in MSR's enforcement gates requires human sign-off for merges to main. This is not a bottleneck — it is the mechanism that prevents agent errors from reaching production. The cost of a 30-second human review is trivially small compared to the cost of an unreviewed agent error in production.

Commercial viability comes from packaging the pattern

MSR's Blueprint Export demonstrates that the ANO model itself is a product. External organizations can purchase a packaged ANO, deploy it via Docker, and operate it with their own data. This creates a revenue stream that funds continued ANO development — a self-sustaining cycle that a purely internal ANO cannot achieve.

Macrohard's revenue model projected future tiers but shipped none. The lesson: ship a minimal commercial product early. Revenue validates the model and funds iteration.

Retain the humans who build the agents

Seven of twelve Macrohard co-founders departed. The head of the Macrohard division left weeks after expanded responsibilities. When the humans who design, build, and coordinate the agent system leave, the system stalls — regardless of how capable the agents are.

This is not a paradox. It is a design constraint. Agent-native organizations still need human architects, human governance, and human strategic direction. The goal is not to eliminate humans from the organization but to multiply human capability through agent infrastructure.

9. Limitations and Future Work

This analysis has several limitations:

Future Work

1. Automated trust calibration: Develop quantitative trust scoring based on agent output quality, adherence to contracts, error rates, and safety event history.

2. ML-based anomaly detection: Replace rule-based circuit breakers and scanners with learned behavioral baselines. Detect novel failure modes that regex patterns miss.

3. Multi-organization ANO study: As more organizations build ANO structures, conduct comparative analysis across domains, scales, and regulatory environments.

4. External ANO deployment: Deploy the Blueprint Export to an external organization and document the setup, adaptation, and operational experience.

5. ANO Maturity Model validation: Survey emerging agent-native organizations and map them to the maturity model. Refine level definitions based on empirical data.

10. Conclusion

Agent-native organizations are viable. MSR Research is the existence proof: 34 agents across six teams, operating in production, generating revenue, processing real workloads, with deployed safety infrastructure and progressive trust. This is not a pitch deck. It is a running system.

Macrohard demonstrated that ambition alone is insufficient. Announcing Level 4 — a "purely AI software company" — without building the infrastructure required at Levels 1–3 produces exactly the outcome observed: leadership departures, engineering attrition, no shipped product, and a strategic pivot.

The failure pattern is predictable and avoidable:

- Skip safety → agents loop, inject, cascade errors

- Skip trust → agents take consequential actions without earned autonomy

- Skip humans → nobody is left to fix what breaks

- Skip progression → the infrastructure gap between ambition and reality is unbridgeable

The path to agent-native organizations runs through agent-coordinated ones. MSR's experience validates this progression: build the agents (Level 1), build the coordination and safety infrastructure (Level 2), earn autonomous operation through demonstrated reliability (Level 3), and only then approach the fully agent-native model (Level 4).

The tools exist. The models are capable. The question is not whether ANOs can work — it is whether organizations are willing to build them incrementally, with discipline, safety, and earned trust, rather than announcing the destination and skipping the journey.

Macrohard skipped. MSR built. The results speak for themselves.

References

1. CNBC. "Musk unveils joint Tesla-xAI project 'Macrohard,' eyes software disruption." March 11, 2026.

2. Electrek. "Musk confirms xAI-Tesla joint 'Digital Optimus' project — after saying Tesla didn't need xAI." March 11, 2026.

3. Sherwood News. "Tesla accelerates AI agent push as xAI's Macrohard falters." March 11, 2026.

4. Seeking Alpha. "xAI stalls Macrohard as Musk ramps up efforts on Tesla's Digital Optimus." March 11, 2026.

5. Fortune. "Half of xAI's founding team has left." February 11, 2026.

6. TechCrunch. "Senior engineers including co-founders exit xAI amid controversy." February 11, 2026.

7. Silicon Republic. "Toby Pohlen latest co-founder to exit xAI." February 2026.

8. SatNews. "SpaceX consolidates xAI operations amid co-founder departures." February 16, 2026.

9. UC Today. "xAI Macrohard — AI Agents Are Coming for Enterprise Software." 2025.

10. WindowsForum. "Macrohard vs Microsoft — AI-Agent Swarms Redefine Windows & Enterprise." 2025.

11. TechtonicShifts. "Macrohard is Musk's middle finger to Microsoft." September 28, 2025.

12. Windows Central. "Meet Macrohard, Elon Musk's AI simulation of Microsoft." 2025.

13. Azernews. "Macrohard AI agent project by xAI reportedly stalled." March 2026.

14. TipRanks. "Elon Musk pauses xAI's 'Macrohard' project." March 2026.

15. Analytics Insight. "Elon Musk restructures xAI after co-founders exit." February 2026.

16. TechBriefly. "xAI details product roadmap for Grok and Macrohard." February 12, 2026.

17. Dataconomy. "xAI's new Macrohard project aims to design rocket engines using AI." February 12, 2026.

18. NextBigFuture. "xAI Macrohard and Digital Optimus is one thing." March 2026.

19. The Information. "xAI's 'Macrohard' Chief Third Co-Founder to Leave This Month." February 2026.

20. The Information. "Musk Restructures xAI Team Amid Senior Departures, SpaceX Merger." February 2026.

21. TechRadar. "Macrohard will take a leaf out of Apple's book." 2025.

22. Musk, Elon. X post. August 23, 2025.

23. Musk, Elon. X post (follow-up on Macrohard scope). September 2025.

24. Wikipedia. "Grok sexual deepfake scandal." 2025–2026.

25. PBS. "Grok chatbot faces EU privacy investigation over sexualized deepfake images." 2025.

26. Invezz. "Musk unveils Tesla-xAI project 'Macrohard' to emulate software companies." March 11, 2026.

27. Ferber, Jacques. Multi-Agent Systems: An Introduction to Distributed Artificial Intelligence. Addison-Wesley, 1999.

28. arXiv:2602.20021. "Agents of Chaos." 2026.

Appendix A: MSR Research Agent Roster

Full roster of 34 agents across 6 teams. Source: `AGENTS.md`, `backend/app/config/agent_registry.py`.

Development Team (11)

Grants Team (8)

Executive (2), Product (4), Coordination (2), Stories (7)

See `AGENTS.md` for full details.

Appendix B: MSR Safety Infrastructure

Deployed components referenced in this paper:

Appendix C: ANO Maturity Model — Diagnostic Questions

For each level, organizations can use these diagnostic questions to self-assess: