Agloom

Production-grade Python agent harness that automatically classifies tasks, optimizes execution, and scales orchestration across eight specialized topologies.

Agloom is a production-grade Python agent harness that automatically classifies tasks, optimizes execution, and scales orchestration from lightweight DIRECT execution to eight specialized LangGraph topologies for efficient, reliable agent workloads.

Documentation | Why Agloom? | Quickstart | Examples | API reference | Agent Skills | GitHub

Building one LLM call is easy. Building an agent that stays predictable when a task needs tools, planning, multiple workers, long context, human approval, remote MCP capabilities, or durable execution is not.

Agloom gives applications one construction API:

from agloom import create_agent

agent = create_agent(model=model, tools=tools)

For each request, Agloom can keep simple work on lightweight DIRECT execution or select one of eight bounded execution topologies when orchestration is useful. Explicit developer configuration always wins.

Agloom provides eight execution topologies plus a direct execution mode. DIRECT is not a topology.

Why teams use Agloom

Quickstart

Install Agloom and your model provider:

uv add agloom langchain-openai

Or with pip:

python -m pip install agloom langchain-openai

Create an agent with a real LangChain model and tool:

import os

from agloom import create_agent
from langchain_core.tools import tool
from langchain_openai import ChatOpenAI


@tool
def multiply(left: int, right: int) -> int:
    """Multiply two integers."""
    return left * right


model = ChatOpenAI(
    model=os.getenv("OPENAI_MODEL", "gpt-4.1-mini"),
    api_key=os.environ["OPENAI_API_KEY"],
)

agent = create_agent(model=model, tools=[multiply])
response = agent.invoke("Use multiply to calculate 17 times 23.")

print(response.content)

Representative result:

17 × 23 = 391.

The executable repository example also asserts that multiply(17, 23) is called exactly once and that the semantic answer contains 391.

Automatic when useful, explicit when required

# Agloom may select DIRECT or any of the eight topologies.
automatic = create_agent(model=model, tools=tools)

# One explicit topology bypasses automatic selection.
planner = create_agent(
    model=model,
    tools=tools,
    pattern="planner",
)

# An allow-list constrains selection to one of these candidates.
constrained = create_agent(
    model=model,
    tools=tools,
    pattern=["planner", "supervisor"],
)

An allow-list is not a composition. Use the Hybrid topology explicitly when a task should pass through multiple child topologies:

hybrid = create_agent(
    model=model,
    tools=tools,
    pattern="hybrid",
    composition=["react", "reflection"],
)

Eight topologies, one runtime

Every topology shares the same lifecycle, events, capability routing, checkpoint integration, streaming surface, and recursion policy.

One capability catalog

Agloom treats capabilities as independent from topology:

Local LangChain tools ─┐
Application services ──┼─> policy ─> retrieval ─> reranking ─> selection
MCP capabilities ──────┘

agent = create_agent(
    model=model,
    tools=local_tools,
    capabilities={"document_store": document_store},
    mcp_client=mcp_client,
    mcp_server_name="operations",
    capability_policy=policy,
    capability_embeddings=embeddings,
    capability_retriever=retriever,
    capability_reranker=reranker,
    max_selected_capabilities=12,
)

selection = await agent.aroute_capabilities(
    "Find the deployment guide and current service status."
)
print(selection.names)

Policy filtering runs first. Optional semantic retrieval and reranking then reduce the catalog to the capabilities relevant to the request. If a task requires a capability that is unavailable, Agloom fails explicitly instead of asking the model to pretend.

Production controls without a new abstraction

from agloom import RecursionPolicy

agent = create_agent(
    model=model,
    tools=tools,
    pattern="planner",
    recursion=True,
    recursion_policy=RecursionPolicy(
        max_depth=2,
        max_subtasks=8,
        max_workers=4,
        max_execution_time=120.0,
    ),
    observers=[prometheus, langfuse],
    structured_output_schema=IncidentReport,
)

The same runnable API can provide:

• synchronous and asynchronous invocation;
• streaming;
• cooperative cancellation;
• bounded recursive child execution;
• LangGraph checkpointing, interrupts, and human approval;
• typed structured output;
• agent-local explainability through agent.xai;
• lifecycle, model, retriever, and tool telemetry.

Agloom does not require LangSmith, a database, containers, or hosted infrastructure. Applications opt into the infrastructure their capabilities need.

Integrated ecosystem

Agloom installs and integrates these capability packages:

Their supported configuration is exposed through create_agent() rather than through a parallel service layer. See the capability guide.

Real examples, not only toy prompts

The repository includes focused scripts for every topology and integration, plus five complete FastAPI/React applications:

examples/24_complete_configuration.py constructs compatible agents that collectively exercise every public create_agent() parameter and fails if a newly added parameter is not demonstrated.

See examples and verified results for executable snippets, semantic assertions, and expected outcomes.

Agent Skills

Agloom publishes one portable Agent Skill for coding agents that integrate, configure, debug, test, or extend the framework:

npx skills add https://github.com/smuniharish/agloom/tree/master/agloom-skills/skills/agloom

The canonical distribution works with Agent Skills-compatible hosts, including Claude Code, Codex, Cursor, and GitHub Copilot. It provides one SKILL.md plus focused architecture, configuration, integration, and troubleshooting references—without maintaining host-specific copies.

Documentation

• Why Agloom?
• Installation
• Quickstart
• Execution topologies
• Capabilities
• Runtime and human approval
• Observability
• Public API guide
• Agent Skills
• Hosted documentation
• GitHub repository

Compatibility

Agloom targets Python 3.12 and is designed as a production-grade, embeddable framework. It does not require LangSmith, containers, a database, or a hosted control plane.

Author

S Muni Harish
samamuniharish@gmail.com

Agloom is licensed under the Apache License 2.0.