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.

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

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

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.

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.