ACOS v10: Autonomous Intelligence

The system that gets smarter every session — with guardrails that prevent it from breaking itself.

TL;DR

ACOS v10 ships five new systems that make the Agentic Creator OS self-improving while keeping it safe. Intelligence score jumped from 72 to 93 out of 100. The key additions: Experience Replay (learning from past successes), Agent IAM (least-privilege access control), Immutable Audit Trail (every action logged), Confidence Circuit Breaker (stops cascading failures), and Conservative Self-Modify Gate (auto-reverts bad config changes). 22 curated skills, 8 specialist agents, 6 IAM-scoped profiles. Hooks optimized from 15 down to 7 for performance. Free on GitHub.

The Problem: Smart Systems That Break Themselves

The previous versions of ACOS were capable but fragile in one specific way: they could modify their own configuration without understanding the consequences.

A system that learns from its mistakes is useful. A system that can change its own rules based on what it learns is powerful. But a system that changes its own rules without validating the result is dangerous.

ACOS v9.3 scored 72/100 on our intelligence benchmark. It had solid foundations — executable routing, n-gram patterns, domain classification, quality gates. But it lacked three things:

1. Memory of what worked before (beyond raw pattern counts)
2. Access control (any agent could touch any file)
3. Rollback safety (config changes were permanent, even bad ones)

v10 fixes all three.

The Five New Systems

1. Experience Replay

Every ACOS session generates a trajectory — a record of what tools were used, in what order, and whether the outcome was successful. By v10, we had 60+ trajectories stored with a 67% average success rate.

Experience Replay does something simple but powerful: when you start a new task, it finds the top 2 most similar past trajectories that succeeded and injects them as context. The system doesn't just know what patterns exist — it remembers how it solved similar problems before.

New task: "Deploy blog post to production"
    → Finds: deployment_traj_1771028043282 (86% success)
    → Finds: deployment_traj_1771038376009 (89% success)
    → Injects both as "here's what worked last time"

The result: fewer repeated mistakes, faster convergence on working solutions.

2. Agent IAM (Identity & Access Management)

Before v10, every agent profile had access to every tool and every directory. The music producer could edit .claude/settings.json. The content writer could run arbitrary bash commands. Not ideal.

Agent IAM introduces per-profile scoping:

This is least-privilege for AI agents. Each profile gets exactly the tools and directories it needs — nothing more.

3. Immutable Audit Trail

Every tool use, every gate decision, every IAM violation, every config change gets logged to an append-only JSONL file. The key word is immutable — entries can be added but never deleted or modified.

This serves two purposes:

• Debugging: When something goes wrong, you can trace exactly what happened
• Trust: You can verify that the system did what it claims it did

The audit trail is the foundation for the next two systems.

4. Confidence Circuit Breaker

If an agent fails on a specific file 3 times, it gets a warning. At 5 failures, it gets restricted. At 8 failures, the circuit breaks — no more operations on that file until the session resets or a success occurs.

File: components/Navigation.tsx
  Attempt 1: Edit failed (syntax error) → tracked
  Attempt 2: Edit failed (wrong context) → tracked
  Attempt 3: Edit failed (conflict) → ⚠️ WARN
  ...
  Attempt 8: → 🔴 CIRCUIT BREAK — stop touching this file

This prevents the most common AI failure mode: trying the same broken approach over and over, making things progressively worse.

5. Conservative Self-Modify Gate

The most important safety system. When ACOS modifies its own configuration:

1. Snapshot the current config state
2. Apply the change
3. Re-score the intelligence benchmark
4. If score drops more than 5 points → automatic rollback to snapshot

This means ACOS can evolve its own rules, but it can never make itself significantly dumber. The system improves monotonically, or it reverts.

The Numbers

The hook reduction from 15 to 7 is a performance story. We removed informational-only hooks, consolidated tracking, and eliminated PostToolUseFailure hooks that added overhead without actionable data. Per-tool-use subprocess spawns dropped from 5-6 to 1-2.

The Status Line

ACOS v10 ships with a new real-time status line that shows system state at a glance:

▊ ACOS v10  FrankX  │  ⎇ main
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
⬡ Skills 22  │  ◆ Agents 8  │  ◈ Profiles 6  │  ⚡ Hooks 7
◉ Intel 93/100  │  Learn [▪▪▪▫▫] 67%  │  ▸ 50 pat  │  ▸ 61 traj  │  ○ idle
▲ Deploy READY  │  ⊕ MCP 6  │  Ctx [░░░░░] 0%
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

Every metric is live. Intelligence score, learning progress, trajectory count, pattern count, deployment readiness, MCP server count, context window usage — all visible without running a command.

Evolution: v7 → v10

The journey from v7 to v10 was a journey from capable to autonomous:

• v7 (Feb 7): Unified orchestration. Claude-flow absorbed. 630+ skills (unvetted). Auto-routing worked but was noisy.
• v8 (Feb 13): Curated intelligence. Pruned to 20 real skills. Exposed that "158 agents" were just session timestamps. Honest numbers.
• v9.0 (Feb 13): Adaptive intelligence. Executable routing, n-gram patterns, domain reclassification. Learning system that actually learns.
• v9.1-9.3 (Feb 13-14): Guardian framework. Quality gates, skill weights, verified intelligence scoring.
• v10 (Feb 14): Autonomous intelligence. Self-improving with safety guarantees. The system that can change itself — carefully.

The honest version: v7 had inflated numbers and broken hooks. The audit (Feb 13) revealed that "630+ skills" were unvetted npm installs and "158 agents" were empty registrations. v8-v10 rebuilt on truth.

What's Next

ACOS v10 is the foundation for what comes next:

• Starlight Intelligence System v4 is already syncing trajectories bi-directionally — patterns flow up from ACOS, context flows down from Starlight
• Cross-session learning via persistent memory means ACOS gets smarter across sessions, not just within them
• Multi-agent coordination with IAM-scoped profiles means agents can work in parallel without stepping on each other

The goal isn't a system that replaces the creator. It's a system that remembers what worked, avoids what didn't, and gets better every time you use it.

Try It

ACOS is open-source and free:

• GitHub: frankxai/agentic-creator-os
• Getting Started: 30-Minute Quick Start
• Deep Dive: Complete Guide
• Philosophy: Technology That Amplifies

Type /acos and describe what you want. The system handles the rest.