MultiAgentOS

Cost-Free Multi-Agent Development Orchestration

MultiAgentOS is a local-first development orchestration platform built around Agent Execution Runtime.

The cost-free baseline does not require a separate paid AI API key. MultiAgentOS connects an already-available AI client with GitHub and a local project while keeping execution authority inside Agent Execution Runtime.

Why MultiAgentOS

MultiAgentOS separates AI collaboration from execution authority.

• ChatGPT Web — single user-facing entry point
• ChatGPT Codex Connector — remote GitHub repository access
• Agent Execution Runtime MCP / Secure Tunnel — local project access
• Orchestrator — top-level multi-agent coordination
• MultiAgentWorkflow — concrete Developer → Tester → Reviewer execution
• Agent Execution Runtime — permission and execution authority

Agents provide intent, plans, and results. They do not directly own filesystem, process, patch, or Git execution authority.

Architecture

                         Web Browser
                              |
                              v
                         ChatGPT Web
                              |
                    +---------+---------+
                    |                   |
                    v                   v
       ChatGPT Codex Connector       Agent Execution Runtime
                    |                MCP / Secure Tunnel
                    v                   |
            GitHub Repository            v
                                  Local Project
                    |                   |
                    +---------+---------+
                              |
                              v
                        MultiAgentOS
                              |
                              v
                         Orchestrator
                              |
                              v
                    MultiAgentWorkflow
                     /       |       \
               Developer   Tester   Reviewer
                              |
                              v
                         Verification
                              |
                              v
                           Agent Execution Runtime

Responsibility boundaries

Multi-agent workflow

Request
  |
  v
Orchestrator
  |
  v
MultiAgentWorkflow
  |
  +--> Developer
  |
  +--> Tester
  |
  +--> Reviewer
  |
  +--> Rework when required
  |
  v
Verification
  |
  v
Completed / Failed

Orchestrator.run_workflow() is the stable higher-level orchestration entry point. MultiAgentWorkflow owns the concrete stage, handoff, review, and rework semantics. MultiAgentRuntime remains an application/runtime adapter and delegates execution to the orchestration boundary.

Agent Execution Runtime remains the execution boundary for permissions, filesystem access, patch application, process execution, Git operations, and verification.

Connection model

Remote GitHub path

ChatGPT Web
    |
    v
ChatGPT Codex Connector
    |
    v
GitHub Repository

This path addresses the remote repository and its durable GitHub state.

Local project path

ChatGPT Web
    |
    v
Agent Execution Runtime MCP / Secure Tunnel
    |
    v
Agent Execution Runtime
    |
    v
Local Project

Agent Execution Runtime has one MCP Server. Secure MCP Tunnel and tunnel-client are transport/connection infrastructure, not another MCP server.

The local Agent Execution Runtime MCP server can be used independently without OpenAI, ChatGPT, a tunnel, or a paid AI API key.

Terminology

Agent Execution Runtime is the descriptive architectural name for the local execution and permission boundary

Cost-Free baseline

The core positioning is simple:

No separate paid AI API key is required for the MultiAgentOS cost-free baseline.

The baseline also does not require:

• a separate agent API subscription
• a MultiAgentOS SaaS subscription
• a second MCP server for the tunnel path

AI-client/product plan limits still apply to the AI service you choose to use. “Cost-Free” describes the MultiAgentOS runtime architecture; it does not mean unlimited AI-service usage.

Verified baseline capabilities

• Agent Execution Runtime MCP stdio initialization and tool discovery
• filesystem READ / WRITE
• patch.apply
• shell.run
• local MCP/runtime tests
• runtime health/readiness
• Secure MCP Tunnel readiness

See Cost-Free Development Baseline for the verification record.

Quick start

Install

python3 -m pip install multiagentos

#Download files on PyPI

Initialize a project

cd your-project
multiagentos init . --component all
multiagentos status .

Run a local task

multiagentos run --path . --objective "run tests" -- python -m unittest discover -s tests -v

Start a Chat Agent session

multiagentos chat --path . --objective "inspect the current project"

Expose the Agent Execution Runtime MCP server

multiagentos mcp serve --path .

For explicit filesystem writes and process execution:

multiagentos mcp serve \
  --path . \
  --allow-write \
  --allow-process

Configuration

Project configuration is stored under .multiagentos/.

The initializer can install:

• components.json — selected components
• execution.json — execution Agent/Model selection
• chat.json — Chat Agent selection
• agents.json — multi-agent catalog
• state/ and session/checkpoint data as applicable

Credentials and provider API keys are not written to project configuration.

Validation

Run the local test suite:

python -m unittest discover -s tests -v

GitHub Actions validates the repository through CI.

Documentation

• Getting Started
• Cost-Free Development Baseline
• Agent Execution Runtime Connection Guide
• Secure MCP Tunnel Setup
• macOS MCP Service
• macOS tunnel-client Service
• Agent Execution Runtime GitHub Connection
• Agent Execution Runtime MCP Architecture
• Agent Plugin Marketplace

The English README is the canonical technical document. Localized READMEs preserve the same architecture, terminology, and cost-free baseline.

한국어 · 日本語 · 简体中文

License

See LICENSE.