glia-agents 0.1.0__tar.gz

glia_agents-0.1.0/.gitattributes

@@ -0,0 +1,4 @@
+# Normalise line endings across platforms.
+* text=auto eol=lf
+*.png binary
+*.jpg binary

glia_agents-0.1.0/.github/workflows/ci.yml

@@ -0,0 +1,40 @@
+name: CI
+
+on:
+  push:
+    branches: [master]
+  pull_request:
+    branches: [master]
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.10", "3.11", "3.12"]
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Python ${{ matrix.python-version }}
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Install (dev extras)
+        run: |
+          python -m pip install --upgrade pip
+          pip install -e ".[dev]"
+
+      - name: Lint (ruff)
+        run: python -m ruff check .
+
+      - name: Tests (pytest, fully offline)
+        run: python -m pytest -q
+
+      - name: Examples run offline
+        run: |
+          for f in examples/0*.py; do
+            echo "--- $f ---"
+            python "$f"
+          done

glia_agents-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,38 @@
+name: Publish to PyPI
+
+# Publishes to PyPI via Trusted Publishing (OIDC) — no API token needed.
+# Configure the trusted publisher once on PyPI:
+#   https://pypi.org/manage/account/publishing/
+#   Project: glia-agents | Owner: DenisDrobyshev | Repo: glia | Workflow: publish.yml
+# Then publishing runs automatically whenever a GitHub Release is published
+# (or manually via the "Run workflow" button / workflow_dispatch).
+
+on:
+  release:
+    types: [published]
+  workflow_dispatch:
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write # required for Trusted Publishing (OIDC)
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Build sdist and wheel
+        run: |
+          python -m pip install --upgrade build
+          python -m build
+
+      - name: Check metadata
+        run: |
+          python -m pip install --upgrade twine
+          python -m twine check dist/*
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1

glia_agents-0.1.0/.gitignore

@@ -0,0 +1,31 @@
+# Python
+__pycache__/
+*.py[cod]
+*.egg-info/
+.eggs/
+build/
+dist/
+*.egg
+
+# Virtual envs
+.venv/
+venv/
+env/
+
+# Tooling caches
+.pytest_cache/
+.ruff_cache/
+.mypy_cache/
+.coverage
+htmlcov/
+
+# Editors / OS
+.vscode/
+.idea/
+.DS_Store
+Thumbs.db
+
+# Local secrets / scratch
+.env
+*.local
+glia_run.json

glia_agents-0.1.0/CHANGELOG.md

@@ -0,0 +1,26 @@
+# Changelog
+
+All notable changes to glia are documented here. Format loosely follows
+[Keep a Changelog](https://keepachangelog.com/); this project uses
+[Semantic Versioning](https://semver.org/).
+
+## [0.1.0] — 2026-07-22
+
+Initial release. Proves the glass-box thesis end-to-end.
+
+### Added
+- Transparent agent loop: `Agent.run()` and `Agent.run_events()` with a full
+  event stream (`RunStarted`, `ModelCall`, `ModelResponse`, `ToolCalled`,
+  `ToolReturned`, `Compacted`, `RunFinished`).
+- `@tool` decorator deriving JSON schemas from type hints (scalars, `Literal`,
+  `Optional`/PEP 604 unions, `list`/`dict`, `Annotated` descriptions).
+- `LLM` provider protocol with two adapters: `ClaudeLLM` (Anthropic SDK,
+  optional dependency) and `EchoLLM` (deterministic, offline, for tests/CI).
+- Serialisable `Trajectory` with checkpoint/resume (`glia.checkpoint`).
+- Context engineering: `SummarizingCompactor` and `TrimmingCompactor`.
+- Input/output guardrails (`glia.guardrails`).
+- Provider-agnostic structured outputs (`generate_structured`).
+- Subagents via `Agent.as_tool(...)`.
+- Evals-as-tests harness (`glia.evals`).
+- Zero-dependency core, `py.typed`, six runnable offline examples, 26 tests,
+  green CI.

glia_agents-0.1.0/CONTRIBUTING.md

@@ -0,0 +1,46 @@
+# Contributing to glia
+
+Thanks for your interest. glia has one guiding principle, and contributions are
+judged against it:
+
+> **No hidden control flow.** A new feature must be inspectable — if you can't
+> see it happen in the event stream or read it in one file, it doesn't fit.
+
+## Setup
+
+```bash
+git clone https://github.com/DenisDrobyshev/glia
+cd glia
+pip install -e ".[anthropic,dev]"
+```
+
+## Checks (all must pass)
+
+```bash
+python -m pytest        # tests — run fully offline, no API key
+python -m ruff check .  # lint
+python -m mypy glia     # types (best-effort)
+```
+
+The whole test suite runs against the offline `EchoLLM`, so it's fast and
+deterministic. New behaviour should come with a test that uses `EchoLLM` — if a
+feature can't be tested offline, that's usually a design smell worth discussing
+first.
+
+## Guidelines
+
+- **Keep the core dependency-free.** New runtime deps go behind an optional
+  extra (like `[anthropic]`), imported lazily.
+- **Prefer a primitive over a feature.** A small composable piece (a new
+  `Compactor`, a new guardrail, a new provider) beats a bespoke flag on `Agent`.
+- **Match the surrounding style.** Readable code with comments that explain
+  _why_, not _what_. The codebase is meant to be read.
+- **New provider?** Implement the `LLM` protocol in ~40 lines; see
+  `glia/providers/echo.py` for the minimal shape.
+
+## Opening a PR
+
+1. Branch from `master`.
+2. Add/adjust tests.
+3. Make sure `pytest` and `ruff` are green.
+4. Describe the change and how it stays inside the glass box.

glia_agents-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Denis Drobyshev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

glia_agents-0.1.0/PKG-INFO

@@ -0,0 +1,179 @@
+Metadata-Version: 2.4
+Name: glia-agents
+Version: 0.1.0
+Summary: A glass-box, minimal library for building LLM agents — modern techniques as opt-in primitives, no hidden control flow.
+Project-URL: Homepage, https://github.com/DenisDrobyshev/glia
+Project-URL: Repository, https://github.com/DenisDrobyshev/glia
+Project-URL: Issues, https://github.com/DenisDrobyshev/glia/issues
+Author: Denis Drobyshev
+License: MIT
+License-File: LICENSE
+Keywords: agent-framework,agents,ai,anthropic,claude,evals,llm,tools
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Typing :: Typed
+Requires-Python: >=3.10
+Provides-Extra: anthropic
+Requires-Dist: anthropic>=0.40; extra == 'anthropic'
+Provides-Extra: dev
+Requires-Dist: mypy>=1.8; extra == 'dev'
+Requires-Dist: pytest>=7; extra == 'dev'
+Requires-Dist: ruff>=0.5; extra == 'dev'
+Provides-Extra: pydantic
+Requires-Dist: pydantic>=2; extra == 'pydantic'
+Description-Content-Type: text/markdown
+
+# glia
+
+**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.
+
+[![CI](https://github.com/DenisDrobyshev/glia/actions/workflows/ci.yml/badge.svg)](https://github.com/DenisDrobyshev/glia/actions/workflows/ci.yml)
+ Python 3.10+  ·  MIT  ·  zero required dependencies  ·  typed
+
+---
+
+## Why another agent library?
+
+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](https://github.com/langchain-ai/langgraph).
+If you want role-play crews, use [CrewAI](https://github.com/crewAIInc/crewAI).
+If you want a small, transparent loop you fully understand — glia.
+
+See [docs/STRATEGY.md](docs/STRATEGY.md) for the full market analysis.
+
+## Install
+
+```bash
+pip install glia-agents               # core — no dependencies
+pip install "glia-agents[anthropic]"  # + the Claude provider
+```
+
+> The distribution is `glia-agents` (the bare name `glia` was taken on PyPI);
+> the import stays `import glia`. For development: `git clone` then
+> `pip install -e ".[anthropic,dev]"`.
+
+## 30-second tour
+
+```python
+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:
+
+```python
+from glia.providers import EchoLLM, call
+llm = EchoLLM([call("get_weather", {"city": "Paris"}), "It's 18°C and cloudy."])
+```
+
+## See the whole glass box
+
+Because the loop emits an event for everything it does, you can watch it work:
+
+```python
+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_finished
+```
+
+And the entire run state is one serialisable object:
+
+```python
+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
+```
+
+## What's in the box
+
+| Primitive | What it gives you |
+|---|---|
+| **Transparent loop** | `agent.run()` / `agent.run_events()` — no hidden control flow |
+| **Typed tools** | `@tool` on a plain function; JSON schema derived from type hints |
+| **Provider boundary** | one ~40-line `LLM` protocol; Claude + offline adapters |
+| **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 |
+
+## Examples
+
+Runnable, offline, no API key needed:
+
+```bash
+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
+```
+
+## Design in one picture
+
+```
+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](docs/ARCHITECTURE.md).
+
+## Project docs
+
+- [Strategy & market analysis](docs/STRATEGY.md) — why glia, and who it competes with
+- [Architecture](docs/ARCHITECTURE.md) — how the whole thing works
+- [Roadmap](docs/ROADMAP.md) — where it's going
+- [Contributing](CONTRIBUTING.md)
+
+## Status
+
+**v0.1 — alpha.** The core thesis is proven end-to-end with a full test suite and
+green CI. APIs may still change before 1.0. Feedback and issues welcome.
+
+## License
+
+MIT — see [LICENSE](LICENSE).

glia_agents-0.1.0/README.md

@@ -0,0 +1,148 @@
+# glia
+
+**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.
+
+[![CI](https://github.com/DenisDrobyshev/glia/actions/workflows/ci.yml/badge.svg)](https://github.com/DenisDrobyshev/glia/actions/workflows/ci.yml)
+ Python 3.10+  ·  MIT  ·  zero required dependencies  ·  typed
+
+---
+
+## Why another agent library?
+
+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](https://github.com/langchain-ai/langgraph).
+If you want role-play crews, use [CrewAI](https://github.com/crewAIInc/crewAI).
+If you want a small, transparent loop you fully understand — glia.
+
+See [docs/STRATEGY.md](docs/STRATEGY.md) for the full market analysis.
+
+## Install
+
+```bash
+pip install glia-agents               # core — no dependencies
+pip install "glia-agents[anthropic]"  # + the Claude provider
+```
+
+> The distribution is `glia-agents` (the bare name `glia` was taken on PyPI);
+> the import stays `import glia`. For development: `git clone` then
+> `pip install -e ".[anthropic,dev]"`.
+
+## 30-second tour
+
+```python
+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:
+
+```python
+from glia.providers import EchoLLM, call
+llm = EchoLLM([call("get_weather", {"city": "Paris"}), "It's 18°C and cloudy."])
+```
+
+## See the whole glass box
+
+Because the loop emits an event for everything it does, you can watch it work:
+
+```python
+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_finished
+```
+
+And the entire run state is one serialisable object:
+
+```python
+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
+```
+
+## What's in the box
+
+| Primitive | What it gives you |
+|---|---|
+| **Transparent loop** | `agent.run()` / `agent.run_events()` — no hidden control flow |
+| **Typed tools** | `@tool` on a plain function; JSON schema derived from type hints |
+| **Provider boundary** | one ~40-line `LLM` protocol; Claude + offline adapters |
+| **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 |
+
+## Examples
+
+Runnable, offline, no API key needed:
+
+```bash
+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
+```
+
+## Design in one picture
+
+```
+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](docs/ARCHITECTURE.md).
+
+## Project docs
+
+- [Strategy & market analysis](docs/STRATEGY.md) — why glia, and who it competes with
+- [Architecture](docs/ARCHITECTURE.md) — how the whole thing works
+- [Roadmap](docs/ROADMAP.md) — where it's going
+- [Contributing](CONTRIBUTING.md)
+
+## Status
+
+**v0.1 — alpha.** The core thesis is proven end-to-end with a full test suite and
+green CI. APIs may still change before 1.0. Feedback and issues welcome.
+
+## License
+
+MIT — see [LICENSE](LICENSE).

glia_agents-0.1.0/docs/ARCHITECTURE.md

@@ -0,0 +1,78 @@
+# Architecture
+
+glia has one rule: **no hidden control flow**. If you want to know what the agent
+does, you read `agent.py`. If you want to know what state it holds, you read
+`trajectory.py`. That's the whole system.
+
+## The pieces
+
+```
+          ┌─────────────────────────────────────────────┐
+          │                  Agent                       │
+          │   the loop: call model → run tools → repeat  │
+          └───────┬───────────────┬──────────────┬───────┘
+                  │               │              │
+          ┌───────▼──────┐ ┌──────▼──────┐ ┌─────▼───────┐
+          │     LLM      │ │ ToolRegistry│ │  Trajectory │
+          │  (protocol)  │ │  (@tool fns)│ │ state+events│
+          └───────┬──────┘ └─────────────┘ └─────────────┘
+                  │
+        ┌─────────┴─────────┐
+   ┌────▼─────┐        ┌─────▼──────┐
+   │ ClaudeLLM│        │  EchoLLM   │
+   │ (Anthropic)        │(offline/CI)│
+   └──────────┘        └────────────┘
+```
+
+| Module | Responsibility | Lines you'd read to understand it |
+|---|---|---|
+| `types.py` | Content blocks, `Message`, `Usage`. Immutable, JSON-serialisable. | ~170 |
+| `llm.py` | The provider boundary: `LLMRequest`, `LLMResponse`, and the `LLM` protocol. | ~90 |
+| `tools.py` | `@tool` decorator (schema from type hints), `ToolRegistry`. | ~230 |
+| `trajectory.py` | The run state + the `Event` types. The glass box itself. | ~250 |
+| `agent.py` | The loop. `run()` and `run_events()`. | ~230 |
+| `memory.py` | Context engineering: compactors. | ~140 |
+| `guardrails.py` | Input/output validators. | ~90 |
+| `structured.py` | Structured output via a forced tool call. | ~110 |
+| `checkpoint.py` | Save/load a trajectory; a checkpointer hook. | ~70 |
+| `evals.py` | Evals-as-tests harness. | ~140 |
+| `providers/` | `EchoLLM` (offline) and `ClaudeLLM` (Anthropic). | ~120 each |
+
+## The loop, precisely
+
+`Agent.run_events()` is the single source of behaviour. Each iteration:
+
+1. **(optional) compact** — if a `Compactor` says the trajectory is too big,
+   shrink it first, emitting a `Compacted` event.
+2. **build an `LLMRequest`** from the current trajectory + tool schemas.
+3. **call the provider** (`ModelCall` → `ModelResponse` events), appending the
+   assistant message and its `Usage` to the trajectory.
+4. **if the model asked for tools:** run each (`ToolCalled` → `ToolReturned`),
+   append all results as one user turn, and loop.
+5. **otherwise:** run output guardrails and finish (`RunFinished`).
+
+`run()` is just `run_events()` drained to completion. That's the whole thing.
+
+## Why these choices
+
+- **Blocks are a closed union, not a class hierarchy.** You `isinstance`/match on
+  four types; there are no subclasses to discover or plugins to register.
+- **Tool results are a `user` turn.** That's the Anthropic convention, and it
+  keeps our message model and the wire format aligned with no translation debt.
+- **Events are records, not commands.** Hooks observe; they never mutate the
+  loop. This keeps behaviour readable and hooks safe.
+- **The provider boundary is tiny on purpose.** Adapting to a new model or an
+  API change touches one file. Vendor churn can't ripple through the codebase.
+- **`EchoLLM` is a first-class citizen.** Deterministic, offline testing of the
+  entire loop is a design goal, not an afterthought.
+
+## Extending it
+
+- **New provider:** implement `async def generate(request) -> LLMResponse`. ~40
+  lines. See `providers/echo.py` for the simplest possible example.
+- **New context strategy:** implement the `Compactor` protocol
+  (`should_compact` + `compact`). See `memory.py`.
+- **New guardrail:** write a `(text) -> None` function that raises
+  `GuardrailTripped`. That's the whole interface.
+- **Observability:** add a hook. Every event flows through it; export to logs,
+  a tracer, or a UI.

glia_agents-0.1.0/docs/ROADMAP.md

@@ -0,0 +1,42 @@
+# Roadmap
+
+glia follows one principle when adding features: **a new primitive must not add
+hidden control flow.** If a feature can't be made inspectable, it doesn't ship.
+
+## v0.1 — thesis proven (this release)
+- Transparent agent loop (`run` / `run_events`) with a full event stream
+- Tools from typed functions (`@tool`) + `ToolRegistry`
+- Provider boundary + `ClaudeLLM` (Anthropic) and `EchoLLM` (offline)
+- Serialisable `Trajectory`; checkpoint/resume (durable execution)
+- Context engineering: `SummarizingCompactor`, `TrimmingCompactor`
+- Guardrails (input/output validators)
+- Structured outputs (provider-agnostic, via forced tool call)
+- Subagents (any agent → a tool)
+- Evals-as-tests harness
+- Zero-dependency core, `py.typed`, green CI, runnable offline examples
+
+## v0.2 — ergonomics & throughput
+- [ ] Parallel tool execution (`asyncio.gather`) with preserved event ordering
+- [ ] Streaming token output through the event stream (`ModelDelta` events)
+- [ ] Retry/backoff policy as an explicit, inspectable wrapper (not hidden magic)
+- [ ] `RunResult` niceties: per-tool timings, cost summary helpers
+
+## v0.3 — interop
+- [ ] MCP tool bridge: expose MCP servers as glia tools, and glia tools as MCP
+- [ ] OpenTelemetry span exporter driven off the event stream
+- [ ] Prompt-caching hints on the Claude adapter (stable-prefix breakpoints)
+
+## v0.4 — reliability
+- [ ] Pluggable persistence backends for checkpoints (file, sqlite, redis)
+- [ ] Deterministic replay: re-run a saved trajectory against a recorded provider
+- [ ] Human-in-the-loop tool approval as a first-class, inspectable gate
+
+## Later
+- [ ] TypeScript port once the Python core stabilises (same glass-box contract)
+- [ ] A tiny local trace viewer that renders a `Trajectory` as a timeline
+
+## Non-goals (on purpose)
+- A graph/DSL orchestration engine — use LangGraph.
+- A hosted runtime/sandbox — use the Claude Agent SDK / Managed Agents.
+- A role-play "crew" abstraction — use CrewAI.
+- Anything that requires the core to grow a heavy dependency.