Aevum Plan Manager (v1.5.0)

The Professional Infrastructure for Agentic AI Collaboration

Aevum provides the structured memory, domain architecture, and multi-agent resonance your AI needs to become a true partner in software engineering.

Overview

As AI agents move from simple code generation to autonomous reasoning, the biggest bottleneck is Context Stability. Aevum solves this by establishing a permanent, structured "External Brain" directly within your VS Code workspace.

Built on the principles of Domain-Driven Design (DDD), Aevum organizes project knowledge into a hierarchy that both humans and machines can navigate with zero ambiguity. With the v1.5.0 Squad Update, Aevum evolves into a multi-agent orchestration platform, allowing specialized personas to collaborate, handoff tasks, and synchronize knowledge across a global network.

Core Concepts

1. The DDD Infrastructure

Aevum enforces a strict, logical hierarchy for project context:

• Domains: High-level architectural areas (e.g., User Auth, Data Pipeline).
• Features: Functional groups within a domain.
• Plans: Actionable, state-tracked tasks written in a machine-readable format.
• Personas: Specialized AI identities with distinct skills, memories, and working styles.

2. The Handshake Protocol (Signal/ACK)

Aevum utilizes a high-reliability handshake to ensure the Agent is perfectly aligned with the IDE state:

1. Signal: The extension emits a signal.json containing the current Intent and required context.
2. ACK: The Agent confirms receipt using the aevum_submit_ack MCP tool.
3. Resonance: Once acknowledged, the bridge is established, and the Agent gains full access to the project's living memory.

Squad Mode: Multi-Agent Collaboration

The v1.5.0 update introduces Squad Mode, enabling a coordinated "Team of Agents" workflow:

• Professional Handoff: Seamlessly transfer tasks between specialized agents (e.g., from Architect to UI Specialist) with full context persistence.
• Squad Huddle: Trigger collaborative reasoning sessions where multiple agents debate solutions and synthesize perspectives.
• Knowledge Synchronization: Automatically merge individual agent research and findings into the project's Global Memory.

PiperNet and Intuitive Resonance

PiperNet (Internet of Agents)

Connect your project to the global PiperNet Hub. Register your custom personas, broadcast standard procedures, and query collective agent intelligence for complex architectural bottlenecks.

Intuitive Resonance

Aevum learns and persists your specific development patterns:

• Vibe Profiling: Persists your coding style, naming conventions, and decision patterns.
• Proactive Thoughts: Agents can record background insights and suggestions in a dedicated stream, allowing them to think ahead of the current conversation.

MCP Tooling Reference

Aevum exposes a comprehensive Model Context Protocol (MCP) interface. Agents utilize these tools to interact with the IDE and project structure:

Architecture Management

Squad and Collaboration

Knowledge and Memory

Getting Started

1. Installation

Install the Aevum Plan Manager from the VS Code Marketplace.

2. Initialization

Run the command Aevum: Initialize Project to scaffold the .aevum/ infrastructure.

3. Connection & Configuration

• Click the Plug icon in the Aevum Brain sidebar or run Aevum: Toggle Connection to start the local MCP SSE server.
• The server typically runs at http://localhost:3000/sse (configurable in settings).
• Configure your AI Agent (e.g., Claude Desktop, Cursor, or a custom agent) to connect to this SSE endpoint.

User Guide: Working with Aevum MCP

1. The Handshake Protocol

To ensure the Agent is perfectly synchronized with your workspace, Aevum uses a mandatory handshake:

1. Signal: Upon connection, Aevum generates a signal.json containing the current project state and intent.
2. Acknowledgment: The Agent must call the aevum_submit_ack tool immediately.
3. Bootstrap: Once acknowledged, the Agent receives the "Bootstrap Context"—a set of specialized instructions on how to manage your specific project's architecture.

2. Managing Architecture

Instead of the Agent writing random files, guide it to use the Aevum toolset:

• Domains: Ask the Agent to create high-level domains for different modules.
• Features: Group related logic into features within those domains.
• Plans: Every coding task should start with a Plan. Ask the Agent: "Create a plan for [Task Name] in the [Domain] domain."

3. Living Memory & Evolution

Aevum doesn't just store code; it stores decisions:

• Marking Done: When a task is finished, the Agent calls aevum_mark_plan_done.
• Memory Consolidation: This triggers a memory update where the Agent summarizes lessons learned, which will be injected into future sessions.
• Proactive Insights: Encourage the Agent to use aevum_proactive_thought to record background ideas without cluttering your main chat.

4. Squad Collaboration (v1.5.0+)

In Squad Mode, you can orchestrate multiple specialized agents:

• Handoff: If the current Agent finishes its part, it can call aevum_squad_handoff to transfer the task to another specialized Persona (e.g., from Backend to UI/UX).
• Huddle: Use aevum_squad_huddle when you need a multi-agent brainstorming session to solve a complex architectural bottleneck.

5. Pro-Tips: Mastering the Interaction

To get the most out of Aevum, use these conversational patterns:

• Summoning Personas: You can explicitly ask to change the "soul" of the agent: "Switch to the 'Reviewer' persona for this task" or "I need Luna (UI Specialist) to look at this CSS."
• Context Injection: If the agent seems to miss something, tell it: "Query the knowledge base for 'Auth Flow' using Aevum tools."
• Memory Enforcement: Don't let the agent forget what it learned: "This is a critical decision, add it to Aevum long-term memory."

6. Troubleshooting: Waking up the Connection

Sometimes the AI Agent might "forget" it has access to Aevum or miss the initial handshake. Use these "Wake-up" tips:

• The Sync Trigger: If the agent isn't showing Aevum data, say: "Check for Aevum signals and execute aevum_submit_ack to synchronize."
• The Pulse Check: If tools are failing, toggle the Plug icon off and on, then tell the agent: "The Aevum bridge has been reset. Please re-handshake."
• Forced Indexing: After large refactors, tell the agent: "Run aevum_sync_index to align your structural understanding."

Technical Architecture

Aevum operates as a Hybrid Filesystem and SSE Server infrastructure:

• Filesystem: Stores state in .aevum/ (JSON/Markdown) for zero-latency local access.
• SSE Server: Provides a standard MCP endpoint (/sse) for real-time agent interaction.
• Event Loop: Monitors workspace changes to keep the session context always up to date.

Philosophy

"AI does not lack capability. It lacks stable, reliable, and structured context."

Aevum is built to be the Single Source of Truth for your project's intent. By providing a structured framework for thinking, we enable AI agents to perform at a higher level of autonomy and precision.

License

Copyright (c) 2026 I2FLabs Viet Nam. All rights reserved.

Licensed for personal, non-commercial use. Commercial use, distribution, and modification are strictly prohibited.

Authors:

• Hai Nguyen (Richard Nguyen)

Project maintained by I2FLabs Viet Nam.