Neo.mjs v11.14.0 Release Notes

The Genesis of the Autonomous Agent.

Just two days after v11.13.0, we are accelerating our roadmap with a transformative release. The Neo.mjs AI ecosystem has evolved rapidly. We began with the Code Execution Pattern ("Thick Client"), enabling agents to write and execute scripts that directly imported our internal services (ai/services.mjs).

With v11.14.0, we are building the next layer of this evolution: the Neo.ai.Agent class.

This release transitions the framework from a collection of powerful tools into a true Agent Operating System. Agents are no longer just ad-hoc scripts; they are now first-class citizens with a standardized lifecycle, a cognitive runtime, and the ability to connect to the wider world via the Model Context Protocol.

📊 Development Velocity This release contains 43 closed issues across 4 major epics, delivered in just 54 hours since v11.13.0. This was achieved through a unique hybrid workflow: human architectural decisions + AI-assisted implementation using the very agents we're building.

✨ Highlights

🧠 The Birth of Neo.ai.Agent & The Cognitive Runtime

We have formalized the agent into a robust class structure. The new Neo.ai.Agent is an autonomous daemon powered by a sophisticated Cognitive Loop:

    ┌────────────────────────────────────┐
    │                                    │
    │   ┌──────────┐     ┌──────────┐    │
    │   │ PERCEIVE │ ──→ │  REASON  │    │
    │   │ (Queue)  │     │  (LLM)   │    │
    │   └──────────┘     └──────────┘    │
    │        ↑                 │         │
    │        │                 ↓         │
    │   ┌──────────┐     ┌──────────┐    │
    │   │ REFLECT  │ ←── │   ACT    │    │
    │   │(Memory)  │     │ (Tools)  │    │
    │   └──────────┘     └──────────┘    │
    │                                    │
    └────────────────────────────────────┘

Key Innovation: The REFLECT phase enables self-correction and continuous improvement without human intervention.

This architecture creates a "Level 3 Autonomy" baseline:

• Level 1: Script-based (must be manually invoked)
• Level 2: Reactive (responds to explicit prompts)
• Level 3: Autonomous (monitors and acts proactively) ← We are here
• Level 4: Collaborative (multi-agent coordination) ← Coming in Phase 4
• Level 5: Self-improving (agents modify their own code)

🧩 Expanding Horizons: MCP Client SDK

We have introduced the MCP Client SDK (Neo.ai.mcp.Client), powered by the @modelcontextprotocol/sdk. This allows Neo.mjs agents to connect to any standard MCP server.

This unlocks two powerful capabilities:

1. Internal Power: Agents can now seamlessly use our three robust, built-in servers via the standard protocol:
   • github-workflow: Full project management.
   • knowledge-base: Semantic search.
   • memory-core: Long-term memory.
2. External Reach: Agents can connect to the broader ecosystem of third-party MCP servers, configured simply via servers: ['my-external-server'].

🖥️ Agent OS: Realizing "The Command Center"

Fulfilling Phase 3 of our roadmap, we have scaffolded the Agent OS (apps/agent-os), a specialized multi-window application designed to visualize and control the swarm.

• Multi-Window Architecture: Separation of concerns with a "Strategy Window" for high-level planning and a "Swarm Window" for real-time intervention.
• Blackboard Visualization: A new Canvas-based graph visualization (PoC) that renders the state of the agent swarm (Issues/Tasks) in real-time using Force-Directed Physics in a dedicated worker.

🏭 The Feature Factory Experiment

We built the system, then used it to build itself. Two specialized agents successfully demonstrated full-cycle autonomous development:

• pm.mjs (Project Manager Agent): Autonomously broke Epic #7961 into sub-issues with proper labels, dependencies, and acceptance criteria.
• dev.mjs (Developer Agent): Converted tickets into working PRs with tests, documentation, and changelog entries.

This experiment validated our architecture under real-world complexity and will inform the design of the full Swarm orchestration layer.

⚠️ Breaking Changes

None. This release is fully backward compatible with v11.13.0.

The new Neo.ai.Agent class is additive and does not affect existing code execution patterns or MCP servers.

🚀 Getting Started with Autonomous Agents

For Existing MCP Server Users:

Your code continues to work unchanged. To upgrade to autonomous mode:

// Before: Manual script execution
const result = await KB_QueryService.queryDocuments({query: 'button'});

// After: Autonomous agent with cognitive loop
const agent = Neo.create(Agent, {
    modelProvider: GeminiProvider,
    servers      : ['knowledge-base']
});

await agent.ready();

agent.schedule({type: 'user:input', data: 'Find button docs'});
agent.start();

The agent now runs continuously, reacting to events and maintaining context.

🤝 A Note on Collaboration

This release was developed in a unique hybrid workflow:

• Architecture & Vision: Human-driven
• Implementation & Testing: AI-assisted via Gemini
• Quality Control: Collaborative review

The cognitive loop agents used the same MCP servers and tools we're releasing, effectively dogfooding the platform in real-time.

🔮 What's Next: Completing The Neural Link

Phase 4 is actively underway. The cognitive runtime (v11.14.0) provides the "brain". Now we're implementing the bidirectional communication layer—the "nervous system":

In Progress:

• Epic #7960: WebSocket RMA Proof of Concept
• Epic #7957: WebSocket RMA Infrastructure
• Epic #7958: Telemetry & Observability (LogBridge)
• Epic #7959: Agent Security & Capabilities

Target: December 2025

This will enable agents to observe browser state in real-time and manipulate applications dynamically via WebSocket RMA, completing the Neural Link architecture outlined in .github/AGENT_ARCHITECTURE.md.

At our current velocity (43 issues in 2 days for v11.14.0), we expect v11.15.0 (Neural Link Complete) to ship within 2 weeks, enabling full bidirectional agent-browser communication.

📦 Full Changelog

🧠 Agent Cognitive Runtime (The Brain)

• Epic: Agent Cognitive Runtime (Issue #7961)
• Integrate Cognitive Loop into Agent Class (Issue #7968)
• Harden Agent Cognitive Loop (Reflection & Error Handling) (Issue #7969)
• Implement Context Window Compression (Issue #7970)
• Polish Agent Loop: Dead Letter Queue & Reflection Safety (Issue #7971)
• Refactor Assembler Configs: Make Counts Configurable (Issue #7972)
• Refactor Loop.mjs configs to be reactive (Issue #7974)
• Implement Neo.ai.provider.Base (Issue #7962)
• Implement Neo.ai.provider.Gemini (Issue #7963)
• Create ContextAssembler for memory integration (Issue #7964)
• Implement Event Queue and Agent Loop (Issue #7965)
• Implement Safety Guardrails for Agent (Issue #7966)

🔌 MCP Infrastructure (The Nervous System)

• Epic: MCP Client Implementation for Agents (Issue #7931)
• Feat: Implement MCP Client SDK and Demo Agent (Issue #7935)
• Feat: Implement MCP Client Configuration (Issue #7936)
• Feat: Implement MCP Client CLI and NPM Script (Issue #7937)
• Refactor: Standardize MCP Client CLI Filename (Issue #7938)
• Feat: Implement Dynamic Tool Proxies for MCP Client (Issue #7939)
• Feat: Add Neo.snakeToCamel utility function (Issue #7940)
• Investigate Multi-Server Tool Namespacing for MCP Client (Issue #7941)
• Feat: Enable External Configuration and Generic Runner for MCP Client CLI (Issue #7942)
• Refactor: MCP Client Lifecycle and CLI Runner Renaming (Issue #7945)
• Feat: Implement Client-Side Tool Validation in MCP Client (Issue #7946)
• Refactor Shared Tool Validation Service for MCP Client and Server (Issue #7949)
• Refactor ToolService to Class-based Architecture (Issue #7950)
• Enhance MCP Client with Connection State and Env Validation (Issue #7951)
• Fix ToolService.mjs Git Case Sensitivity Issue (Issue #7952)
• Refactor Client Configuration Consistency (Issue #7953)

🖥️ Agent OS Application (The Body)

• Task: Scaffold Agent OS Application (Issue #7954)
• Feat: Implement Agent OS Multi-Window Layout (Issue #7955)
• Feat: Multi-Window Orchestration Baseline (Issue #7956)
• Feat: Real-time 'Blackboard' Visualization (Issue #7921)
• Design: Agent Dashboard Layout (Multi-Window Architecture) (Issue #7920)

🧪 Feature Factory Prototypes (The Experiment)

• Task: Define Agent Task Protocol (Labels, Templates, Rules) (Issue #7915)
• Feat: Create 'PM Agent' MVP (Epic -> Ticket Breakdown) (Issue #7916)
• Feat: Create 'Dev Agent' MVP (Ticket -> PR) (Issue #7917)

🛠️ Core Framework & Utilities

• Feat: Expose LocalFileService in AI SDK (Issue #7927)
• Bug: GitHub HealthService fails in standalone SDK scripts (Issue #7930)
• Fix timestamp format mismatch in Memory Core service (Issue #7932)
• Fix misleading sessionId examples in Memory Core OpenAPI (Issue #7933)
• Fix: Sync missing sub-issues and enhance activity log (Issue #7947)
• Enhancement: Timeline-Based Relationship Discovery for Issue Sync (Issue #7948)

🐛 Bug Fixes

• Colors.view.ViewportController: openWidgetInPopup() breaks (Issue #7973)
• examples.component.multiWindowHelix.ViewportController: throws when clicking on the detach window button (Issue #7967)

All changes delivered in 1 atomic commit: https://github.com/neomjs/neo/commit/535b580d03e7c4b68fa2f1023b4c93153c897b73

Gemini 3 working on the new Agent Swarm Command Center App on its own (using an automated chrome via the Chrome Devtools MCP Server):

This already includes OffscreenCanvas and remote method access into the Canvas Worker:

https://github.com/user-attachments/assets/86f963e6-ecc9-4134-8fb9-79c4131e219c