---
orphan: true
---

# Project Status

OpenRath v1.2.0 is a usable multi-agent, multi-session runtime with first-class memory, internal async execution, provider integrations, and active hardening around lifecycle and durability. The main abstractions are implemented in `src/rath`, covered by tests, documented in the API reference, and exercised by the numbered example ladder. It is not yet a fully polished platform with long-term compatibility guarantees for every extension point.

```text
Core model          Runtime path          Durability layer        Project quality
Session/Workflow -> async loop + tools -> persistence/config  ->  CI/docs/examples
Backend/Memory      local/OpenSandbox     local JSON/JSONL        Ruff + Actions
```

```{figure} _static/release-highlights-overview.png
:alt: OpenRath release highlights overview

OpenRath v1.2.0 expands the runtime around memory, internal async execution,
provider modalities, lifecycle hardening, and project quality.
```

```{figure} _static/multi-agent-multi-session.png
:alt: Multi-agent multi-session runtime

The v1.2 runtime treats multi-agent and multi-session flows as first-class
session graph operations.
```

## Current Stage

| Layer | Status | What this means |
| --- | --- | --- |
| Session core | Implemented and central | `Session` carries transcript chunks, sandbox placement, lineage, usage, and branch operations. |
| Workflow API | Implemented | `Workflow`, `Agent`, `AgentParam`, and `Compressor` provide the main composition surface. |
| Tool runtime | Implemented | `FlowToolCall` bridges model-visible schemas to backend side effects. |
| Memory plane | Implemented | Local memory is in the base install; OpenViking is optional; agents expose remember / recall / commit APIs. |
| Local backend | Usable | Local command, file, and code payloads are supported and covered by conformance tests. |
| OpenSandbox backend | Integrated, still operationally sensitive | Container execution works, with workspace bind fallback and CI coverage, but depends on external service/runtime setup. |
| LLM providers | Expanded | OpenAI-compatible and Anthropic adapters exist behind a provider registry; embedding and VLM clients are available. |
| Streaming | Implemented for compatible clients | `run_session_loop(on_event=...)` supports OpenAI-compatible and Anthropic streaming deltas while keeping durable assistant chunks. |
| Async runtime | Implemented internally | Public calls stay synchronous; returned sessions may lazily synchronize transcript and usage fields. |
| Persistence | Implemented, still early UX | Session JSONL persistence, WAL partials, sandbox identity registry, and memory registry pieces exist. |
| MCP integration | Implemented as adapter | Stdio MCP tools can be wrapped as `FlowToolCall`; transport scope is intentionally narrow. |
| CI and lint | In place | Ruff, pre-commit, pytest-xdist, timeout/rerun plugins, and GitHub Actions cover lint, tests, shellcheck, OpenSandbox, and OpenViking paths. |
| Documentation | Updated for v1.2.0 | API reference and tutorials cover the new memory, async, provider, and example surfaces. |

## What Is Stable Enough To Build On

These areas are the current foundation of the project:

| Capability | Evidence in repo |
| --- | --- |
| Session state model | `src/rath/session/session.py`, `chunk.py`, `loop.py`, `compress.py` |
| Workflow composition | `src/rath/flow/workflow.py`, `agent.py`, `agent_param.py`, `compressor.py` |
| Backend abstraction | `src/rath/backend/abc.py`, `local.py`, `tool_types.py`, `results.py` |
| Memory abstraction | `src/rath/memory/abc.py`, `op_types.py`, `results.py`, `registry.py` |
| LLM request/response DTOs | `src/rath/llm/chat_request.py`, `chat_response.py` |
| OpenAI-compatible client path | `src/rath/llm/openai/` |
| Core tutorials/examples | `docs/source/tutorial/`, `example/01_hello_agent.py` through `example/10_provider_variation.py` |
| Test coverage shape | `tests/session/`, `tests/backends/`, `tests/llm/`, `tests/flow/`, `tests/memory/`, `tests/concurrency/` |

The repository currently has dozens of focused test files across session behavior, backends, provider adapters, persistence, MCP, and conformance. That makes the codebase closer to an early framework than a one-off demo.

## What Recently Moved From Design Into Runtime

The latest development line adds memory, internal async execution, and lifecycle hardening around the core runtime:

| Area | Runtime change |
| --- | --- |
| Memory plane | `rath.memory` mirrors backend concepts with `MemoryBackend`, `MemoryStore`, `MemoryOp*`, results, registry, local backend, and optional OpenViking adapter. |
| Provider ecosystem | Registry-based dispatch through `chat_client_for(...)`, plus Anthropic support. |
| Embedding and VLM | `EmbeddingProvider`, `VLMProvider`, and OpenAI-compatible thin clients support memory ranking and image description use cases. |
| Config | Persistent `~/.openrath/config.json` with LLM, MCP, and memory sections. |
| Internal async runtime | `run_session_loop(...)` can return a lazy session while work proceeds on the private runtime. |
| Session persistence | Append-only JSONL writer/loader with WAL partials, crash detection, and resumable pairs. |
| Sandbox persistence | Local workspace and OpenSandbox remote identity registry. |
| Sandbox lifecycle | Refcounted live handles shared by loop outputs, forks, detaches, and merges, with lock-protected acquire/release. |
| Merge primitive | `Session.merge(...)` keeps `self.sandbox`, records merge lineage, and no longer rejects cross-sandbox merges. |
| Streaming loop | `on_event` callback receives `RathLLMStreamDelta` values from OpenAI-compatible and Anthropic streaming clients. |
| MCP tools | Stdio MCP servers can be exposed to the loop as normal `FlowToolCall` tools. |
| LLM resilience | Retry policy, credential fallback, token usage accounting, and budget guardrail. |
| Example ladder | `example/` is now a numbered 01-10 progression from hello agent to provider variation. |
| Project operations | Ruff, pre-commit, pytest-xdist, timeout/rerun plugins, and split GitHub Actions matrices. |

```{figure} _static/ci-tooling-pipeline.png
:alt: OpenRath CI and tooling pipeline

The current contributor path is guarded by Ruff, type checks, tests, docs builds,
and GitHub Actions workflows.
```

## What Still Needs Productization

These are the main areas that need continued work before the project feels like a mature public platform:

| Area | Current gap |
| --- | --- |
| Persistence UX | Low-level APIs exist; user-facing resume/cleanup workflows need clearer tutorials and examples. |
| Config UX | JSON config is implemented; CLI helpers or guided setup are not yet present. |
| MCP scope | Stdio transport works; HTTP/SSE transports are not part of the current adapter. |
| OpenSandbox operations | Backend integration exists; production deployment still depends on server/runtime configuration. |
| OpenViking operations | Optional memory backend exists; deployment still depends on service/runtime configuration. |
| Docs coverage | Public API reference and tutorials are aligned with v1.2.0; deeper persistence and OpenViking walkthroughs can still expand. |
| Release communication | Long-form announcement content should live on `blog.openrath.com`, not inside this docs site. |
| Compatibility policy | Current release is `v1.2.0`; memory, async, embedding, and VLM extension points should be treated as evolving until maintainers publish a stricter policy. |

## Practical Interpretation

For a new user:

- OpenRath is ready to try for local agent workflows, structured session experiments, custom tools, local memory, and provider integration work.
- It is especially useful if you want session state, tool execution, and workflow composition to be explicit Python objects.
- For production use, validate provider credentials, memory store paths, sandbox lifecycle, persistence cleanup, and OpenSandbox/OpenViking deployment in your environment.

For a contributor:

- The next highest-value work is not inventing new abstractions; it is tightening the user path around the abstractions that now exist.
- Good follow-up work includes persistence tutorials, config setup helpers, OpenSandbox/OpenViking deployment notes, MCP transport expansion, and docs images for the new runtime layers.