Continuum: A Local Shared Memory and Controlled Workflow Framework for AI Programming Agents

Continuum is a lightweight open-source framework focused on providing local shared memory and controlled workflows for AI programming agents. It aims to address core pain points in multi-agent collaboration such as state isolation and coordination difficulties, while maintaining deployment simplicity and fine-grained control over the execution process. Its design philosophy is to break down state barriers between agents, allow knowledge and context to flow continuously, and help teams efficiently integrate AI agents to assist in development.

With the improved capabilities of large models like Claude and GPT-4, AI programming agents have become practical, but multi-agent collaboration faces four major challenges: state isolation (difficulty sharing context), coordination difficulties (lack of standardized orchestration mechanisms), insufficient controllability (no human review for key operations), and resource competition (conflicts in file/database operations). Existing frameworks such as AutoGen and CrewAI rely on external services or distributed architectures, leading to high deployment and operation costs.

Local Shared Memory System

• Hierarchical Storage: Global context (public knowledge base), session state (temporary data), agent private space, message queue (asynchronous communication).
• Persistence: By default, stored in the local file system, supporting fault tolerance (crash recovery), observability (direct content viewing), and audit tracking (operation history replay).
• Concurrency Safety: File locks control consistency, and memory caching reduces disk I/O.

Controlled Workflow Engine

• Phase Definition: Specify executor, input/output locations, preconditions, and post-actions.
• Control Point Mechanism: Pause at key phases to wait for human review (e.g., code submission, database modification).
• Error Handling: Phase retries, compensation operations (rollback), timeout control, and graceful degradation.

1. Code Review Pipeline: Static analysis agent (linter/type checking) → security scanning agent → performance analysis agent → comprehensive review agent (generates report). Shared results avoid repeated scans.
2. Multi-step Code Generation: Requirements analysis → architecture design → code implementation → testing → documentation update. Results from each phase are written to shared memory for subsequent agents to use.
3. Human-Agent Collaborative Development: Agent generates code draft → pauses to wait for human review → modifies based on feedback → submits PR after human confirmation, balancing AI efficiency and human control.

• Minimal Dependencies: Core dependencies are only standard libraries and a few tools, making it easy to integrate into existing environments.
• Language Agnosticism: Multi-language SDKs (mainly Python), shared data uses JSON format for cross-language parsing.
• Pluggable Agent Adapters: Supports LLM agents (Claude/GPT-4), local models, and traditional automation scripts.
• Security Sandbox: Optional mechanism to restrict file access and system commands, reducing the risk of AI agent execution.

Feature	Continuum	AutoGen	CrewAI	Traditional CI/CD
Local-first	✅	❌	❌	✅
Shared Memory	✅	✅	⚠️	❌
Lightweight	✅	⚠️	⚠️	✅
Human Control Points	✅	⚠️	⚠️	✅
Code Focused	✅	⚠️	⚠️	✅

Continuum is positioned as a 'lightweight local multi-agent orchestration tool' to fill the gap in existing solutions.

Current Limitations

• Scale Limitation: File system-based shared memory is not suitable for ultra-high-frequency concurrent scenarios.
• Distributed Support: Currently only supports single-machine deployment; multi-machine collaboration requires additional development.
• Ecosystem Maturity: Fewer tools and integrations compared to mature frameworks like AutoGen.

Future Plans

• Visual Interface: Web UI to view workflow status and shared memory content.
• Plugin System: Support for custom storage backends (Redis, SQLite).
• Template Marketplace: Predefined templates for common development workflows.
• IDE Integration: Deep integration with editors like VS Code.

Summary

Continuum adopts a pragmatic approach, focusing on efficient collaboration in local environments. It addresses core pain points of multi-agent collaboration through shared memory and controlled workflows, making it suitable for teams that want to introduce AI agents but are unwilling to bear the cost of complex infrastructure.

Quick Start

1. Installation: pip install continuum.
2. Initialization: Create a shared memory directory and workflow definition file.
3. Define Agents: Use the SDK to read and write shared memory.
4. Orchestrate Workflow: Define phase order and dependencies.
5. Execution: Run the workflow and observe collaboration.

Sample code demonstrates a two-phase workflow: agent generates code draft → another agent reviews and modifies it.