A complete, pluggable Agent Runtime evolving from a verified Rust Core, with stable interfaces for real products to supply their own capabilities.
Agent systems become difficult to reason about when model calls, state changes, streaming output, and side effects collapse into one opaque function.
Looper separates those responsibilities into a visible execution lifecycle. The current repository begins with one session, one foreground run, an in-memory event store, and a simulated model effect. That is the first verified implementation slice—not the final product scope.
The destination is a complete Runtime module: the Core keeps execution semantics coherent, while extension interfaces let real business applications replace capabilities without forking or rebuilding the loop.
Core owns the invariants. Extensions own the things that must vary between products.
The Core is responsible for session and run state, command ordering, pure decisions, durable facts, effect scheduling, event publication, and recovery semantics.
Products inject adapters for external and business-specific behavior. Looper defines lifecycle contracts and error modes; each application chooses the implementations.
Each interface describes what a caller must know at its seam. Adapters can change without leaking provider or deployment complexity into the Core.
Inference, streaming deltas, completion, usage metadata, cancellation, and provider errors. The current proof uses a simulated streaming adapter; real providers are next.
Capability discovery, schema validation, execution, progress, results, and failures for local tools, MCP servers, or product-owned actions.
The current Event Store is in memory. The interface will support durable session events, snapshots, artifacts, and optional long-term memory implementations.
Ordered runtime facts and ephemeral progress for UI subscribers, audit logs, metrics, tracing, indexing, and product workflows.
Permissions, budgets, approvals, sandbox requirements, organization rules, and decisions that may allow, deny, or pause an effect.
CLI and HTTP/SSE prove the seam today. Future adapters can expose JSON-RPC, queues, workers, or application-specific interfaces.
Every accepted command travels through the same explicit stages.
Serializes commands and completed effects for a single session actor.
Purely calculates domain events and requested effects from current state and input.
Persists durable facts first; the prototype uses an in-memory adapter.
Applies stored events to rebuild the session’s in-memory state.
Publishes durable facts and ephemeral streaming deltas to subscribers.
Executes requested work and returns the result to the mailbox to close the loop.
The current milestone proves the minimum Core loop and its first adapters. It does not yet claim the complete production Runtime.
Looper is a headless Runtime module, not a preselected business Agent.
A coding assistant, browser operator, data diagnostic Agent, or experiment runner defines its workflows, prompts, data, UI, and business rules.
The product supplies Model, Tool, Memory or Storage, Event, Policy, and Transport adapters at Looper’s extension seams.
Looper owns lifecycle, ordering, state transitions, effects, recovery semantics, and observable events across every business integration.
These milestones deepen the existing Core and turn the planned extension seams into production-ready interfaces. They are roadmap items, not current capability claims.