01
Receive prompt
Use the CLI, Python API, FastAPI backend, or MCP-compatible editor workflow.
Latest release 1.8.2
Omni-agent orchestration for local and cloud work
Limbi runs many specialized AI agents from one command, one Python API, or one MCP-compatible editor workflow. It keeps workspace memory, tracks execution, and supports both local models and cloud providers without forcing you into one narrow style of work.
0
Registered agents
0
Agent actions
0
Provider modes
0
Workspace aware
What Limbi focuses on
Control, memory, and practical execution
Limbi is not trying to be a generic chat box. It is designed to coordinate work, preserve context, keep results auditable, and let you move between local and cloud providers without reworking the whole flow.
Orchestration
Many agents, one control plane
Limbi delegates work to specialized agents and brings the results back into one response, rather than making one model guess everything at once.
Memory
Workspace-aware continuity
Shared session memory and episodic logs keep the current goal, route, and project context available across turns and across agents.
Providers
Local first, cloud when needed
Ollama, local OpenAI-compatible servers, routers, and hosted providers all fit into the same workflow.
Execution
Auditable work, not hidden magic
Limbi tracks runtime metrics, traces, and saved artifacts so you can see what happened and why.
Docs
Read the structure before you run it
These notes walk through Limbi in the same order a new user usually needs it: what it is, how it behaves, how to install it, and what happens after a prompt enters the system.
Doc 01
Start here
Limbi is not just a chat wrapper. It is an orchestration layer that chooses providers, routes tasks to agents, keeps workspace state, and tries to make the result auditable and repeatable.
Doc 02
Installation
You can install Limbi with Homebrew, the one-line curl installer, or pip. The docs explain when each route makes sense, plus what to check if the local setup or tap gets out of sync.
Doc 03
How it works
A prompt enters the CLI, the orchestrator loads memory and workspace context, decides whether the task should be researched, delegated, or handled directly, and then returns a concise answer with traces and runtime metrics.
Doc 04
Deploy and operate
The website ships through GitHub Pages and GitHub Actions. The product itself can run locally, with hosted providers, or through the provider modes and runtime settings described in the README.
Structure
README map
The README follows the same path as the site: project focus, runtime behavior, agent catalog, capabilities, installation, provider selection, troubleshooting, and deployment. That means a visitor can start on the website and still find the deeper technical shape of Limbi without having to guess where to look next.
Agent.md
One shared guide for every provider
Limbi can load a provider-neutral agent.md file from the workspace root,
or an override from .limbi/agent.md, then share that guidance with the
orchestrator and every agent. That keeps behavior consistent whether the model is
local, hosted, or routed through a different provider.
How it works
From prompt to orchestrated result
Every request follows the same high-level path: load workspace context, classify the task, run the right agents, and return a response with a visible execution summary.
02
Plan and route
The orchestrator checks memory, route confidence, research context, and provider choice.
03
Delegate work
Structured delegation blocks send tasks to the right agent and action.
04
Return answer
The response includes the result, runtime metrics, and a trace for review.
What problem Limbi solves
Four recurring problems, one platform
The platform is built to reduce the friction that usually appears when work is split across many tools, many prompts, and many provider endpoints.
Problem 01
Tool fragmentation
One orchestration layer replaces a tangle of separate tools and manual copy-paste steps.
Problem 02
Generic responses
Specialized agents can focus on planning, code, research, operations, or review instead of guessing.
Problem 03
Lost context
Shared memory keeps relevant project state available so the next turn starts with more than a blank slate.
Problem 04
Weak execution trail
Audit logs, traces, and runtime metrics show what happened instead of hiding it behind a single reply.
Agent catalog
Specialized agents ready to use
Limbi ships with a broad catalog for reasoning, engineering, cloud, security, business, and domain-specific work.
Cognitive and reasoning
14 agents
planner_agent
critic_agent
router_agent
memory_agent
swarm_agent
evaluation_agent
learning_agent
research_agent
Engineering and delivery
14 agents
code_agent
file_agent
git_agent
testing_agent
docs_agent
data_agent
browser_agent
scheduler_agent
Cloud and operations
21 agents
devops_agent
cicd_agent
sre_agent
aws_agent
gcp_agent
kubernetes_agent
security_agent
compliance_agent
Business and domain work
18 agents
finance_agent
hr_agent
marketing_agent
healthcare_agent
education_agent
real_estate_agent
logistics_agent
media_agent
Capabilities
Designed for real engineering work
Limbi combines memory, research, skills, runtime metrics, and provider flexibility into one workspace-aware system.
Core
Graph-backed session memory
Shared context uses graph-linked memory and episodic logs so the current goal, route, and project state survive across turns and agents.
Research
URL grounded and live search
Limbi can summarize a provided URL or search the web when the prompt asks for research without one.
Skills
Custom skill system
Create, update, delete, export, and import skills. Keep them local, share them as packs, and let them inherit or pin a provider.
Installation
Three install paths
Pick the route that fits your machine. The page below matches the README install paths and keeps the commands easy to copy.
Choose a path
interactive
Homebrew is best for macOS, pip is the most direct Python route, and the one-line installer is useful for quick setup on Linux, macOS, and WSL2.
terminal - brew
Provider modes
Local, cloud, and router friendly
Limbi supports local model servers, hosted providers, and compatible OpenAI-style endpoints without changing your workflow.
Ollama
Ollama Cloud
LM Studio
vLLM
LocalAI
KoboldCpp
llama.cpp
OpenAI
Anthropic
Google
Groq
OpenRouter
Hugging Face
Mistral
Azure OpenAI
Cohere
Together AI
Chutes
Bytez
Troubleshooting
Common install issues, simple fixes
If Brew or a local provider gets out of sync, these are the small repair steps that usually get you moving again.
Homebrew
Brew still shows an older version
Refresh the tap repo directly with git -C "$(brew --repo sayon999-d/limbi)" pull --ff-only and then run brew upgrade limbi.
Local models
Provider asks for a key on localhost
Check that the base URL is local and that the selected model is actually installed. For Ollama, make sure the server is running and the model exists.
Cloud providers
Provider or model decommissioned
If a hosted model is retired, switch to a live model from /models and save the new preference.
Built for a clean white glass deployment with modern motion and no decorative icons.
Limbi version 1.8.2