What Aionis Runtime is

Aionis Runtime is a self-evolving continuity runtime for agent systems.

Short version

Aionis Runtime is the public runtime layer in this repository. It exists to make repeated work start better, paused work resume cleanly, and successful work become reusable operating knowledge.

Task startStructured handoffReplay and playbooksLite runtime today

What ships today

Aionis Runtime ships today as a local runtime with typed SDK access to task start, handoff, replay, policy memory, semantic forgetting, sandbox execution, and automation.

See what ships today.

Aionis Runtime is the public runtime in this repository.
Lite is the runtime shape that ships publicly today.

The purpose of the runtime is straightforward:

1. help repeated work start with better execution context
2. help paused work resume from structured runtime state
3. help successful work become reusable operating knowledge

The default product path

Core

Continuity baseline

Use write, planning or task start, handoff, and replay to prove that repeated work no longer starts from zero and paused work no longer resumes from guesswork.

write -> planning/taskStart -> handoff -> replay

Enhanced

Self-improvement loop

Add lifecycle reuse, review packs, and sessions so the runtime can reactivate useful nodes, record reuse quality, and expose continuity state to humans or hosts.

rehydrate -> activate -> reviewPacks -> sessions

Advanced

Kernel control surfaces

Add experience intelligence, execution introspection, delegation records, tools, rules, patterns, and payload helpers when you need a deeper learning and governance substrate.

introspect -> delegate -> tools/rules/patterns

Why this matters

The public memory surface is wide. If you present everything as one flat story, users either miss the real power or feel buried in endpoints. The layered product path solves that: the core path proves continuity, the enhanced path proves self-improvement, and the advanced path exposes deeper substrate controls for more serious hosts.

The failure it targets

The concrete failure is agent continuity:

1. a familiar task comes in and the agent still starts from zero
2. a paused task is resumed and the agent has no trustworthy execution state
3. a successful repair finishes and the knowledge disappears instead of becoming reusable

That failure is especially visible in coding workflows, but the same pattern appears anywhere reliable startup guidance, pause/resume, or replay reuse matters.

What Aionis Runtime does

The runtime exposes three core surfaces:

1. Task start Turn prior execution into a better first action for the next similar task.
2. Task handoff Store execution-ready handoff packets with target files, next action, and recovery context.
3. Task replay Record successful runs, compile reusable playbooks, and promote them into stable workflow guidance.

Around those surfaces, Lite also exposes local automation, sandbox, and review-oriented runtime paths.

Where the other valuable surfaces fit

Not every valuable capability belongs in the first evaluation loop.

• experienceIntelligence(...) and executionIntrospect(...) belong in the advanced path because they help a host inspect and tune how learning is accumulating.
• sessions.* and reviewPacks.* belong in the enhanced path because they make continuity persist beyond a single answer and make review possible.
• delegationRecords.* belongs in the advanced path because it matters most when multi-agent learning becomes explicit.
• tools.*, rules.*, and patterns.* belong in the advanced path because they govern learned behavior rather than simply exposing outputs.

What "self-evolving" means here

In Aionis, self-evolving means that later execution can be informed by earlier execution through explicit runtime structures:

1. previous execution evidence can influence the next task start
2. a paused task can be resumed from structured handoff state
3. successful runs can be replayed, compiled, and promoted into reusable playbooks
4. memory lifecycle routes can rehydrate useful nodes and record activation feedback
5. stable feedback can materialize policy memory that later review and governance can inspect or retire

The system improves because continuity is persisted and reused, not because the product merely promises "AI memory".

core continuityenhanced reuseadvanced controlsAionis should feel deeper over time, not heavier on day one.

Single-agent and multi-agent use

The current public runtime is especially well suited to:

• coding agents
• ops and automation agents
• task-oriented hosts that need pause/resume
• multi-agent systems that need trustworthy handoff between workers

The common requirement is continuity.

Where it fits

Aionis Runtime fits underneath the model, host, and workflow layers as the continuity layer that helps work carry forward across runs.

Why the runtime shape matters

The key design choice is that continuity is exposed as runtime infrastructure:

• typed SDK contracts instead of hidden prompt state
• replay, handoff, and kickoff as explicit APIs
• local persistence instead of fragile session text
• automation and sandbox capability around those same flows

This makes the runtime easier to inspect, integrate, validate, and extend.

How the execution loop works

This is the loop Aionis is trying to own. The runtime turns prior execution into better later execution.

What ships today

• a Lite local runtime with SQLite-backed persistence
• a public SDK through @ostinato/aionis
• replay, handoff, automation, sandbox, and review-pack surfaces
• validation evidence through smoke tests, contract tests, and benchmark reports

How to think about the public product

Use this mental model:

Layer	What it means
Aionis Runtime	The public runtime shape you integrate against
Lite	The local distribution that ships publicly today

If you are evaluating or integrating Aionis, you mainly care about Aionis Runtime and Lite.

Recommended reading order

1. Why Aionis
2. Architecture Overview
3. Getting Started for the core path
4. SDK Quickstart for the full layered path
5. Task Start
6. Handoff
7. Replay
8. Action Retrieval
9. Uncertainty and Gates
10. Memory for enhanced and advanced surfaces
11. Lite Runtime
12. Contracts and Routes

Start using it

Getting Started

Boot Lite locally, point the SDK at it, and confirm the runtime is alive.

Integrate it

SDK Quickstart

Write memory, ask for task start, store handoff, and move into replay through the public client.

Understand it

Architecture Overview

Read the runtime shell, bootstrap, host, and store seams that make Lite easy to understand.

After this page

If you want to keep going in the shortest useful order:

1. read Why Aionis for the differentiators
2. read Architecture Overview for the runtime shape
3. read Getting Started or SDK Quickstart to evaluate the public path