A glass-box, minimal library for building LLM agents. Every model call, tool call, and state transition is a plain object you can log, snapshot, and replay. No hidden control flow. The whole loop fits in one file you can read in an afternoon.
glia (n.): the cells that support and connect neurons. This is the connective tissue for LLM agents — not a framework you submit to, a small library you build on.
Python 3.10+ · MIT · zero required dependencies · typed
The desktop shell — streaming reply on the left, the live glass box on the right. (Animated SVG; it plays in your browser.)
The 2026 agent-framework field is crowded, and the loudest, most consistent complaint about the incumbents is the same: too much abstraction, hidden control flow, painful to debug. Developers keep stripping the framework out to call the model API directly, just to see what's happening.
glia is the opposite bet. It ships the modern techniques — tools, structured outputs, context compaction, durable checkpoints, guardrails, subagents, evals-as-tests — as opt-in primitives you can read, not a monolith you must trust. The design goal is understandability and control, not feature count.
If you want a graph engine, use LangGraph. If you want role-play crews, use CrewAI. If you want a small, transparent loop you fully understand — glia.
See docs/STRATEGY.md for the full market analysis.
pip install glia-agents # core — no dependencies
pip install "glia-agents[anthropic]" # + the Claude providerThe distribution is
glia-agents(the bare namegliawas taken on PyPI); the import staysimport glia. For development:git clonethenpip install -e ".[anthropic,dev]".
import asyncio
from glia import Agent, tool
from glia.providers import ClaudeLLM
@tool
async def get_weather(city: str) -> str:
"""Get the current weather for a city."""
return {"Paris": "18°C, cloudy"}.get(city, "unknown")
async def main():
agent = Agent(ClaudeLLM(), tools=[get_weather], system="Be concise.")
result = await agent.run("What's the weather in Paris?")
print(result.output) # the answer
print(result.usage) # what it cost
asyncio.run(main())No API key handy? Every example runs offline with the deterministic EchoLLM
provider — same code, no network:
from glia.providers import EchoLLM, call
llm = EchoLLM([call("get_weather", {"city": "Paris"}), "It's 18°C and cloudy."])Because the loop emits an event for everything it does, you can watch it work:
async for event in agent.run_events("What's the weather in Paris?"):
print(event.kind)
# run_started → model_call → model_response → tool_called → tool_returned → model_call → ... → run_finishedAnd the entire run state is one serialisable object:
from glia.checkpoint import save, load
save(result.trajectory, "run.json") # durable execution: it's just JSON
resumed = load("run.json")
await agent.run("follow-up question", trajectory=resumed) # pick up where you left off| Primitive | What it gives you |
|---|---|
| Transparent loop | agent.run() / agent.run_events() — no hidden control flow |
| Streaming | Agent(..., stream=True) — tokens arrive as ModelDelta events |
| Typed tools | @tool on a plain function; JSON schema derived from type hints |
| Parallel tools | a turn's tool calls run concurrently, results kept in order |
| Approval gate | approval=... — an inspectable human-in-the-loop verdict before any tool runs |
| Provider boundary | one ~40-line LLM protocol; Claude, OpenAI, local (Ollama), and offline adapters |
| MCP tools | use any Model Context Protocol server's tools as glia tools ([mcp] extra) |
| Trajectory | the full, JSON-serialisable run state and event log |
| Structured output | generate_structured(...) → a dataclass / Pydantic model / dict |
| Context engineering | SummarizingCompactor, TrimmingCompactor |
| Durable execution | checkpoint & resume — a run is a JSON file |
| Guardrails | (text) -> None validators for input and output |
| Subagents | agent.as_tool(...) — any agent becomes a tool |
| Evals-as-tests | a pytest-style regression harness for agent behaviour |
| Record & replay | record real provider responses once, replay deterministically offline (VCR-style) |
| OpenTelemetry | OTelExporter hook turns the event stream into spans ([otel] extra) |
Runnable, offline, no API key needed:
python examples/01_hello_agent.py # basic agent + event stream
python examples/02_tools.py # tools
python examples/03_structured_output.py # typed output
python examples/04_subagents.py # subagent as a tool
python examples/05_checkpoint_resume.py # durable execution
python examples/06_evals.py # eval suite
python examples/07_streaming_and_approval.py # streaming + parallel tools + approval gate
python examples/08_ollama_local.py # run a local model (Qwen/DeepSeek) via Ollama
python examples/09_record_replay.py # record once, replay deterministically offlineglia ships a graphical shell — a chat window that also shows the live glass box (streaming tokens, tool calls, approvals) as it happens.
- Download a standalone build for your OS from the latest release (
glia-shell-windows.exe/-macos/-linux) — no Python needed. - Or
pip install "glia-agents[shell]"thenglia-shellfor a native window.
It works offline in demo mode out of the box; add an Anthropic API key in Settings to chat with real Claude. The whole app is stdlib + one HTML file — see docs/app.md.
Agent.run() → [ call model → (tools? run them, loop) : done ]
│ │
every step emits an Event you can see, log, and replay
│
all state lives in one serialisable Trajectory
Full details in docs/ARCHITECTURE.md.
- Documentation site — full guide, available in English and Русский
- Strategy & market analysis — why glia, and who it competes with
- Architecture — how the whole thing works
- Roadmap — where it's going
- Contributing
v0.8 — alpha. The core thesis is proven end-to-end with a full test suite (167 offline tests, ~95% coverage) and green CI (ruff + mypy + tests). v0.8 redesigns the desktop shell into a modern multi-conversation app (sidebar with persistent history, Markdown/code rendering, theme toggle); v0.7 an OpenTelemetry exporter; v0.6 record/replay cassettes; v0.5 OpenAI + interactive approval + MCP; v0.4 local models via Ollama; v0.3 a downloadable desktop shell; v0.2 streaming, parallel tools, and the approval gate. APIs may still change before 1.0. Feedback and issues welcome.
MIT — see LICENSE.