limbi 1.0.1

Omni-Agent Orchestration Platform — 87 specialised AI agents, any LLM provider.

⚡ Limbi

Omni-Agent Orchestration Platform

Limbi turns a single natural-language request into coordinated work across specialised AI agents for engineering, cloud, security, operations, analytics, business workflows, and domain-specific tasks.

---

What Is Limbi?

Limbi is a pip-installable Python platform and CLI for running an AI agent swarm from your terminal, Python code, HTTP API, VS Code, or MCP-compatible tools.

Instead of asking one general-purpose model to do everything alone, Limbi gives the model a structured way to delegate work to focused agents such as security_agent, devops_agent, git_agent, database_agent, aws_agent, jira_agent, docs_agent, testing_agent, research_agent, and many more.

It works with local and hosted models through a provider layer:

• Ollama for local-first workflows.
• OpenAI, Anthropic, Google Gemini, Groq, Mistral, Azure OpenAI, Cohere, Together AI, and OpenAI-compatible APIs.
• A CLI, Python API, FastAPI backend, Gradio UI, VS Code extension, and MCP server path.
• Shared context memory so agents can build on each other's findings.
• Audit logs, retry logic, RAG/codebase ingestion, and workspace-level configuration.

---

Why I Built This

Modern AI tools are powerful, but real work is rarely a single prompt. A deployment task may need release notes, security checks, Git context, CI/CD actions, observability review, Jira updates, rollback planning, and documentation. A normal chatbot can suggest those steps, but it does not naturally coordinate them.

Limbi was built to solve that gap.

The goal is to make AI assistance feel closer to an operating layer for real projects:

• One request, many skills: ask once, let the orchestrator route the work.
• Specialised reasoning: use agents shaped around real domains instead of one generic answer.
• Provider freedom: switch between local and cloud models without rewriting your workflow.
• Memory between agents: when one agent discovers something important, the next agent can use it.
• Developer control: keep the system inspectable through logs, databases, APIs, and plain Python code.

Limbi is for builders who want AI to move beyond "answer my question" into "coordinate this workflow with the right tools and context."

---

The Problem Limbi Solves

Most AI automation breaks down in four places:

Problem	What Happens Without Limbi	What Limbi Adds
Generic assistants	One model tries to be a DevOps engineer, security reviewer, planner, and documentation writer at once.	87 focused agents with explicit actions.
Tool fragmentation	Every provider, API, local model, and workflow needs separate glue code.	A single provider abstraction and orchestration layer.
Lost context	Results from one step are forgotten or manually copied into the next prompt.	Shared context memory and execution history.
No operational trail	It is hard to know what ran, what failed, and why.	Audit logging, retries, structured delegation results, and workspace state.

---

Architecture

flowchart TD
    User["User<br/>CLI · Python · API · VS Code · MCP"] --> Workspace[".limbi workspace<br/>config · logs · sessions · memory"]
    User --> Orchestrator["Limbi Orchestrator"]

    Workspace --> Orchestrator
    Orchestrator --> Provider["LLM Provider Layer"]

    Provider --> Ollama["Ollama<br/>local models"]
    Provider --> Hosted["Hosted providers<br/>OpenAI · Anthropic · Gemini · Groq · Mistral · Azure · Cohere · Together"]
    Provider --> Compatible["OpenAI-compatible APIs<br/>LM Studio · vLLM · custom gateways"]

    Orchestrator --> Parser["Delegation Parser<br/>structured JSON blocks"]
    Parser --> Registry["Agent Registry<br/>87 agents · 410 actions"]

    Registry --> Cloud["Cloud & DevOps<br/>AWS · GCP · Azure · Kubernetes · CI/CD · SRE"]
    Registry --> Engineering["Engineering<br/>Code · Git · DB · Testing · Migration · Docs"]
    Registry --> Security["Security & Governance<br/>Security · Compliance · Policy · Audit"]
    Registry --> Business["Business & Domains<br/>Finance · Sales · Legal · Healthcare · Education · more"]

    Registry --> Results["Agent Results"]
    Results --> Audit["Audit Log<br/>execution history"]
    Results --> Context["Shared Context Memory<br/>inter-agent handoff bus"]
    Results --> Response["Final Answer<br/>conversation + execution summary"]

    Context --> Orchestrator
    Audit --> Orchestrator
    Response --> User

Architecture Explanation

The user sends a natural-language request from the CLI, Python, API, VS Code, or an MCP client. Limbi initializes the local .limbi workspace, loads configuration, connects to the selected LLM provider, and builds a system prompt containing the registered agents, recent executions, retrieved codebase context, and shared agent memory.

The LLM can answer normally or emit structured delegation blocks. Limbi parses those blocks, runs the selected agents, retries failed executions when appropriate, records the outcome in the audit log, publishes the result into shared context memory, and returns a final response that includes both the conversation and the executed work.

---

Multi-Agent Flow

sequenceDiagram
    autonumber
    participant U as User
    participant O as Orchestrator
    participant L as LLM Provider
    participant P as Payload Parser
    participant A as Agent Registry
    participant M as Context Memory
    participant D as Audit DB

    U->>O: "Review this service and prepare deployment"
    O->>M: Load shared session context
    O->>D: Load recent executions
    O->>L: Prompt with agents, memory, RAG, history
    L-->>O: Conversation + JSON delegations
    O->>P: Parse delegation blocks
    P-->>O: security_agent, testing_agent, devops_agent
    par Execute independent agents
        O->>A: Run security_agent.scan
        O->>A: Run testing_agent.plan
        O->>A: Run devops_agent.deploy
    end
    A-->>O: Structured results
    O->>D: Store execution logs
    O->>M: Publish results for later agents
    O-->>U: Final answer + execution summary

This design lets Limbi behave like a coordinator, not just a chatbot. The orchestrator stays responsible for routing, memory, retries, logs, and final synthesis while individual agents stay focused on their own domain.

---

Agent System

Limbi currently registers 87 agents with 410 available actions.

Category	Example Agents
Cognitive orchestration	planner_agent, critic_agent, router_agent, react_agent, swarm_agent, learning_agent
Engineering	code_agent, git_agent, file_agent, database_agent, testing_agent, migration_agent
Cloud and platform	aws_agent, gcp_agent, azure_agent, kubernetes_agent, api_gateway_agent
DevOps and reliability	devops_agent, cicd_agent, sre_agent, incident_agent, performance_agent, observability_agent
Security and governance	security_agent, compliance_agent, policy_agent, auth_agent, approval_agent
Data and intelligence	data_agent, analytics_agent, nlp_agent, research_agent, knowledge_agent, reporting_agent
Business workflows	finance_agent, sales_agent, payments_agent, cost_agent, procurement_agent, customer_success_agent
People and operations	hr_agent, recruiting_agent, onboarding_agent, scheduler_agent, project_management_agent
Industry domains	healthcare_agent, education_agent, legal_agent, real_estate_agent, manufacturing_agent, logistics_agent, travel_agent, agriculture_agent
Memory and context	memory_agent, context_memory_agent, feedback_agent, audit_log integration

List everything from your terminal:

limbi --list-agents

---

Key Features

• Natural-language orchestration: ask for an outcome, not a specific script.
• Parallel delegation: independent agent tasks can run together.
• Retry logic: transient agent failures are retried with exponential backoff.
• Shared context memory: agent outputs are automatically published into a session memory bus.
• Codebase RAG: index local project files with ChromaDB and retrieve relevant context during chat.
• Audit trail: execution history is stored so you can inspect recent actions.
• Provider switching: change models through CLI flags, .limbi/config.json, or environment variables.
• Workspace isolation: each project can have its own .limbi config, logs, sessions, memory, and vector store.
• Multiple interfaces: CLI, Python API, FastAPI server, Gradio UI, VS Code extension, and MCP server.

---

Installation

1. Install From PyPI

pip install limbi

Important: pip install limbi only installs the Limbi command into your active Python environment. It does not create a limbi/ folder in your current project. The project-local workspace is created later, when you run the limbi command.

2. Install With Provider Extras

pip install "limbi[openai]"
pip install "limbi[anthropic]"
pip install "limbi[google]"
pip install "limbi[groq]"
pip install "limbi[mistral]"
pip install "limbi[cohere]"
pip install "limbi[azure]"
pip install "limbi[rag]"
pip install "limbi[all]"

3. Local Development Install

git clone https://github.com/sayonmanna/limbi.git
cd limbi
python -m venv .venv
source .venv/bin/activate
pip install -e ".[all]"

---

Install vs Workspace Initialization

When you install Limbi inside a virtual environment, Python places the package inside that environment's site-packages directory and adds the limbi CLI command to the environment's bin/ folder.

For example:

mkdir my-ai-workspace
cd my-ai-workspace

python -m venv .venv
source .venv/bin/activate

pip install limbi

At this point, your folder will usually still only contain the virtual environment:

my-ai-workspace/
└── .venv/

Now run Limbi once from that folder:

limbi --list-providers

That first run creates the hidden project workspace:

my-ai-workspace/
├── .venv/
└── .limbi/
    ├── config.json
    ├── chroma_db/
    ├── logs/
    └── sessions/

Because .limbi starts with a dot, it is hidden by default on macOS and Linux. Use this command to see it:

ls -a

If limbi is not found after installation, make sure your virtual environment is active:

source .venv/bin/activate
which limbi
limbi --help

If your project path contains spaces, such as project 4, the generated .venv/bin/limbi script may fail on some systems with bad interpreter. Use module execution instead:

python -m limbi --help
python -m limbi --generate-mcp-config

---

Quick Start

Local-First With Ollama

Limbi defaults to Ollama.

ollama serve
ollama pull llama3.2:3b
limbi "what agents do you have?"

Use A Hosted Provider

export LLM_PROVIDER=openai
export LLM_MODEL=gpt-4o
export LLM_API_KEY="sk-..."

limbi "review this repository for security and deployment risks"

You can also pass provider options directly:

limbi --provider anthropic --model claude-sonnet-4-20250514 "write a migration plan"
limbi -p groq -m llama-3.1-70b-versatile "explain this Kubernetes incident"

Interactive Mode

limbi

Inside the REPL:

/agents      list registered agents
/providers   list supported providers
/clear       clear chat history
/help        show commands
/quit        exit

---

Configuration

On first run, Limbi creates a project-local workspace:

.limbi/
├── config.json
├── audit.db
├── memory.db
├── context_memory.db
├── chroma_db/
├── logs/
└── sessions/

Important environment variables:

Variable	Default	Purpose
LLM_PROVIDER	ollama	Provider name.
LLM_MODEL	llama3.2:3b	Model to use.
LLM_API_KEY	empty	API key for hosted providers.
LLM_BASE_URL	http://localhost:11434	Local or compatible API base URL.
LLM_TEMPERATURE	0.3	Model sampling temperature.
LLM_MAX_TOKENS	4096	Maximum output tokens.
AZURE_DEPLOYMENT	empty	Azure OpenAI deployment name.
AZURE_API_VERSION	2024-06-01	Azure OpenAI API version.

You can edit .limbi/config.json to set project defaults, then override them with CLI flags or environment variables when needed.

---

CLI Usage

# One-shot task
limbi "create a release checklist for this project"

# Provider and model override
limbi --provider openai --model gpt-4o "review this code for security issues"

# Inspect the system
limbi --list-agents
limbi --list-providers
limbi --help

# Launch through Python module execution
python -m limbi "summarize the architecture"

Useful prompts:

limbi "plan a zero-downtime database migration and list rollback steps"
limbi "review this project for missing documentation and create a README outline"
limbi "act as a release coordinator: check testing, deployment, and monitoring concerns"
limbi "route this request to the right agents and explain why"

---

Python API

import asyncio
from limbi import Orchestrator, list_agents, get_llm_provider

async def main():
    print(f"Agents: {len(list_agents())}")
    print(get_llm_provider().info())

    orch = Orchestrator(session_id="demo")
    result = await orch.chat(
        "Plan a production deployment and identify security, testing, and rollback tasks."
    )

    print(result["conversation_text"])
    print(result["delegations_executed"])

asyncio.run(main())

Codebase RAG

Install RAG support:

pip install "limbi[rag]"

Index a project:

from limbi import Orchestrator

orch = Orchestrator()
stats = orch.ingest_codebase("/path/to/your/project")
print(stats)

result = orch.vector_store_stats()
print(result)

Once indexed, Limbi can retrieve relevant local code context while answering future prompts.

---

FastAPI Server

For the full backend, install server dependencies:

pip install "limbi[server]"

From the repository root:

uvicorn main:app --reload

Useful endpoints:

Endpoint	Purpose
GET /health	Backend health.
POST /api/chat	Send a chat message to the orchestrator.
GET /api/agents	List registered agents and actions.
POST /api/agents/{agent_name}/{action}	Run a specific agent action.
GET /api/audit/executions	Inspect recent executions.
POST /api/rag/ingest	Index a directory for RAG.
GET /api/rag/stats	View vector store statistics.
GET /api/system/rate-limits	Inspect rate-limit state.

Example:

curl -X POST http://127.0.0.1:8000/api/chat \
  -H "Content-Type: application/json" \
  -d '{"message":"prepare a deployment plan for staging","stream":false}'

---

MCP And VS Code

Limbi includes an MCP server that exposes agent actions as MCP tools. The easiest way to configure it is from the terminal:

python -m limbi --generate-mcp-config

That writes:

.vscode/mcp.json

with a packaged MCP server command:

{
  "servers": {
    "limbi": {
      "type": "stdio",
      "command": "/path/to/python",
      "args": ["-m", "limbi.mcp_server"]
    }
  }
}

You can also run the MCP server directly:

python -m limbi.mcp_server

VS Code Extension

The VS Code extension in limbi-vscode/ can connect to the FastAPI backend and generate MCP configuration too.

Development flow:

uvicorn main:app --reload
cd limbi-vscode

Open limbi-vscode in VS Code and press F5 to launch the Extension Development Host.

Then open the VS Code Command Palette with Cmd+Shift+P on macOS or Ctrl+Shift+P on Windows/Linux, search for Limbi: Generate MCP Config, and press Enter.

Limbi: Generate MCP Config is a VS Code command-palette command, not a terminal command. Running Limbi: Generate MCP Config or limbi: Generate MCP Config in zsh/bash will show command not found.

Make sure the command starts with Limbi:. Commands such as React Native: Create EAS config file for Expo come from other VS Code extensions and are unrelated to Limbi.

If you do not see any Limbi: commands in the Command Palette, the Limbi VS Code extension is not running yet. Use python -m limbi --generate-mcp-config from the terminal, or open the limbi-vscode/ folder in VS Code and press F5 using the Run Limbi Extension launch configuration.

---

Use It To Full Potential

1. Choose The Right Provider

Use Ollama for privacy and local experiments:

export LLM_PROVIDER=ollama
export LLM_MODEL=llama3.2:3b

Use a hosted model for deeper reasoning or heavier workflows:

export LLM_PROVIDER=openai
export LLM_MODEL=gpt-4o
export LLM_API_KEY="sk-..."

Use an OpenAI-compatible local server:

export LLM_PROVIDER=openai_compatible
export LLM_BASE_URL="http://localhost:1234/v1"
export LLM_MODEL="local-model-name"
export LLM_API_KEY="not-needed"

2. Start With Outcome-Based Prompts

Good Limbi prompts describe the goal, constraints, and expected output:

Review this repository as a release engineer. Identify blockers, testing gaps,
security risks, deployment steps, rollback plan, and documentation updates.
Return a prioritized checklist.

Plan a cloud migration for this app. Consider cost, security, observability,
data migration, CI/CD, compliance, and team handoff.

3. Let Agents Chain Context

Use multi-step prompts where one agent's result should inform another:

First analyze security and compliance risks. Then use those findings to build
a deployment approval checklist and a monitoring plan.

Because Limbi auto-publishes execution results into shared context memory, later agents can see what earlier agents discovered.

4. Index Your Codebase

For project-aware answers, install RAG support and ingest your repository:

pip install "limbi[rag]"

from limbi import Orchestrator

orch = Orchestrator()
orch.ingest_codebase(".")

Then ask:

limbi "explain the architecture of this codebase and identify risky modules"

5. Check The Execution Trail

Use the API or local .limbi databases to inspect what ran. This is especially useful when Limbi delegates multiple actions.

curl http://127.0.0.1:8000/api/audit/executions

---

Troubleshooting

chromadb not installed - vector store unavailable

ChromaDB is only needed for Limbi's optional codebase RAG features. If you installed the basic package with:

pip install limbi

normal chat can still work. To enable codebase indexing and vector search, install the RAG extra:

pip install "limbi[rag]"

Then run your prompt again:

limbi "explain this project using local code context"

limbi: command not found

Activate your virtual environment first:

source .venv/bin/activate
which limbi
limbi --help

Package 'limbi' requires a different Python

Limbi requires Python 3.11 or newer. Check your virtual environment:

python --version

If it shows Python 3.10 or older, recreate the environment with Python 3.11+:

deactivate
rm -rf .venv
python3.11 -m venv .venv
source .venv/bin/activate
pip install limbi

python -m limbi.mcp_server shows no response

That is expected. The MCP server is a stdio server, so it waits for an MCP client to send JSON-RPC input. In normal use, you do not chat with it directly from the terminal.

Generate the MCP config instead:

python -m limbi --generate-mcp-config

Then let your MCP-capable editor or client launch it from .vscode/mcp.json.

---

Provider Matrix

Provider	Install	Configuration
Ollama	pip install limbi	LLM_PROVIDER=ollama
OpenAI	pip install "limbi[openai]"	LLM_PROVIDER=openai LLM_API_KEY=sk-...
Anthropic	pip install "limbi[anthropic]"	LLM_PROVIDER=anthropic LLM_API_KEY=...
Google Gemini	pip install "limbi[google]"	LLM_PROVIDER=google LLM_API_KEY=...
Groq	pip install "limbi[groq]"	LLM_PROVIDER=groq LLM_API_KEY=gsk_...
Mistral	pip install "limbi[mistral]"	LLM_PROVIDER=mistral LLM_API_KEY=...
Azure OpenAI	pip install "limbi[azure]"	LLM_PROVIDER=azure LLM_BASE_URL=... AZURE_DEPLOYMENT=...
Cohere	pip install "limbi[cohere]"	LLM_PROVIDER=cohere LLM_API_KEY=...
Together AI	pip install "limbi[together]"	LLM_PROVIDER=together LLM_API_KEY=...
OpenAI-compatible	pip install "limbi[openai]"	LLM_PROVIDER=openai_compatible LLM_BASE_URL=...

---

Project Structure

limbi/
├── cli.py                 # Click-powered terminal interface
├── orchestrator.py        # Core routing, prompting, delegation, retries
├── llm_provider.py        # Provider abstraction for local and hosted models
├── vector_store.py        # ChromaDB-backed RAG/codebase retrieval
├── workspace.py           # .limbi workspace initialization and config
├── audit_log.py           # Execution logging
└── agents/                # 87 specialised agents

main.py                    # FastAPI + Gradio backend
limbi_mcp_server.py        # MCP server exposing Limbi tools
limbi-vscode/              # VS Code extension
pyproject.toml             # Published package metadata

---

Roadmap Ideas

• Richer agent capability metadata and examples.
• More production-grade connectors for cloud and SaaS systems.
• Web dashboard for execution history and context memory.
• Stronger policy controls for approval-gated actions.
• More MCP-first workflows for editor-native automation.

---

License

Apache 2.0. See LICENSE.

---

Author

Built and published by Sayon Manna.

If Limbi helps you coordinate real work with AI agents, star the repository and share what you build with it.