Aionis RuntimeSelf-evolving execution memory for agent systems.

Aionis Runtime learns from every run to improve task starts, stabilize handoffs, reuse successful workflows, and forget intelligently.

Run Lite locally

See proof by evidence

View on GitHub

Better task starts

Prior execution gives the next similar task a stronger first action instead of another generic cold start.

Structured handoff

Pause with target files, recovery anchors, and next action stored as explicit runtime state.

Replay that becomes reusable

Successful execution gets recorded, promoted into stable workflows, and reused through playbooks.

Policy memory

Repeated successful execution can materialize into governable policy memory.

Semantic forgetting

Memory cools, relocates, and rehydrates by lifecycle instead of accumulating forever.

Typed runtime surface

SDK, routes, stores, sandbox, and automation all stay explicit and inspectable.

npx @ostinato/aionis-runtime start

Lite ships todaySDK v0.3.0Apache-2.0 licensed15 / 15 benchmark scenarios

Positioning

Aionis Runtime turns task start, handoff, replay, policy memory, and semantic forgetting into one unified execution-memory loop, so agent systems do not restart from zero every time. They can continue from prior execution, improve over time, and reuse what already worked.

Public product shape

The public product shape today includes the standalone runtime package, Lite, the public TypeScript SDK, the local Inspector and Playground interfaces, and the docs site that explains the product, mechanisms, proof path, and route surfaces.

@ostinato/aionis-runtimeLite runtime@ostinato/aionisInspector / PlaygroundDocs + proofs

Design Principles

Principle 1

Execution first

Aionis learns from real task starts, handoffs, replays, repairs, and governance instead of treating chat history as the product.

Principle 2

Continuity first

The next start, the next resume, and the next reuse path are exposed as explicit runtime surfaces.

Principle 3

Self-evolution first

Each run can strengthen the next run through better task starts, better replay, and clearer policy memory.

Principle 4

Intelligent forgetting first

Memory is managed through demotion, archive, relocation, and on-demand restoration instead of growing without control.

Core Capabilities

Capability	What it does	Primary surface
Task Start	Produces a stronger first action for the next similar task	`memory.taskStart(...)`, `memory.planningContext(...)`
Task Handoff	Stores structured recovery state across runs, including target files and next action	`handoff.store(...)`, `handoff.recover(...)`
Task Replay	Records successful execution, promotes stable workflows, and reuses playbooks	`memory.replay.run.`, `memory.replay.playbooks.`
Action Retrieval	Exposes the explicit next-action retrieval layer with evidence, source kind, and retrieval surfaces	`memory.actionRetrieval(...)`, `memory.experienceIntelligence(...)`
Uncertainty Layer	Turns weak retrieval into explicit gates such as inspect, widen recall, rehydrate payload, or request review	`memory.taskStart(...)`, `memory.planningContext(...)`, `operator_projection.action_hints[]`
Policy Memory	Materializes repeated successful execution into governable policy memory	`memory.tools.feedback(...)`, `memory.reviewPacks.evolution(...)`
Semantic Forgetting	Moves memory through retain / demote / archive / review and supports differential rehydration	`memory.archive.rehydrate(...)`, `memory.anchors.rehydratePayload(...)`
Session / Review / Inspect	Exposes continuity state, evolution state, and review entry points	`memory.sessions.`, `memory.agent.`, `memory.executionIntrospect(...)`
Sandbox / Automation	Executes local shell, playbook, and automation flows	Lite runtime, sandbox, automation routes

Action Retrieval And Uncertainty Layer

Aionis does not stop at remembering prior execution. It exposes an explicit action-retrieval layer that answers the runtime question directly: what should the agent do next, what evidence supports it, and how certain is that recommendation.

What this layer now exposes

The runtime can now return explicit retrieval evidence, source-kind signals, uncertainty levels, gate actions, and operator hints instead of flattening everything into one overconfident first step.

memory.actionRetrieval(...)gate_actionwiden_recallrehydrate_payloadrequest_operator_reviewoperator_projection.action_hints[]

This means weak retrieval can now escalate task start instead of pretending to be a confident answer. Hosts and operators can inspect the gate surface directly and decide whether to inspect context, widen recall, or rehydrate colder payload before acting.

Self-Evolving Mechanism

What the proof path already shows

The self-evolving loop is already defended by six live Lite proofs: better second task start, policy memory materialization, governance loop, continuity provenance preservation, session continuity promotion, and semantic forgetting with differential rehydration.

task-start-proofpolicy-memorypolicy-governancecontinuity-provenancesession-continuitysemantic-forgetting

Observed proof from six live Lite runs on 2026-04-18

Demo 1

Better second task start

The same task moved from a generic cold start to a learned file-aware startup.

cold: tool_selection → warm: experience_intelligence

src/services/billing.ts

Demo 2

Policy memory materialized

Repeated positive execution feedback became persisted policy memory instead of staying as loose hints.

materialization_state = "persisted"

selected_policy_memory_state = "active"

Demo 3

Governance loop proved

The runtime retired policy memory and reactivated it with fresh live evidence through the public route.

active → retired → active

live_policy_selected_tool = "bash"

Demo 4

Provenance survived promotion

Stable workflow guidance kept explicit continuity provenance instead of erasing where the learning signal came from.

distillation=handoff_continuity_carrier

distillation=session_event_continuity_carrier

Demo 5

Session continuity promoted a stable workflow

Repeated session state now counts as distinct workflow observations instead of depending on an event-only path.

distillation=session_continuity_carrier

observed_count = 2

Demo 6

Semantic forgetting cooled memory without deleting it

Archived workflow memory now surfaces lifecycle decay, cold relocation, and differential payload restore instead of silently disappearing.

semantic_forgetting.action = "archive"

rehydration_mode = "differential"

Forgetting Mechanism

How forgetting works

Aionis treats forgetting as lifecycle control. Memory is cooled, relocated, and restored when needed. It is not left to accumulate forever, and it is not reduced to blind deletion either.

semantic_forgetting_v1archive_relocation_v1archive rehydratedifferential rehydration

Continuity Mechanism

Continuity 1

Start better

Prior execution improves the kickoff for the next similar task instead of forcing another generic first step.

Continuity 2

Resume cleanly

Handoff packets store recovery anchors, target files, next actions, and resume context as runtime state.

Continuity 3

Reuse successful work

Replay runs feed playbook promotion, repair review, and stable workflow reuse across later execution.

Full Architecture

Architectural stance

Continuity, self-evolution, forgetting, and governance all live on explicit runtime seams. The SDK, routes, stores, sandbox, and automation path are visible and inspectable by design.

Benchmarks And Validation

Metric	Current result	Entry point
Runnable self-evolving proofs	`6`	Proof By Evidence
Real-provider A/B snapshot	`31 / 31` vs thin · `25 / 25` vs chat · `25 / 25` vs vector	Validation and Benchmarks
Strict replay reuse	`3 / 3`, `0` replay tokens	Validation and Benchmarks
Lite runtime test suite	`211 / 211`	`npm run -s lite:test`
Public SDK test suite	`14 / 14`	`npm run -s sdk:test`

Evidence6 live proofs

Task start improvement, policy memory, governance, provenance, session continuity, and semantic forgetting are all defended by runnable Lite evidence.

Benchmarks31/31 · 25/25 · 25/25

Real-provider A/B coverage now spans repeated starts, forgetting, replay, multi-cycle refinement, and production simulation.

SDK tests14 / 14

The public SDK surface is validated directly instead of only being implied by route behavior.

Lite tests211 / 211

The current Lite runtime baseline stays green across replay, recall, handoff, policy, forgetting, and automation.

Quick Start

1. Start Aionis Runtime

bash

npx @ostinato/aionis-runtime start

If you are working from a source checkout instead of the published runtime package:

bash

npm install
npm run lite:start

2. Integrate the SDK into your own project

bash

npm install @ostinato/aionis

import { createAionisClient } from "@ostinato/aionis";

const aionis = createAionisClient({ baseUrl: "http://127.0.0.1:3001" });

const taskStart = await aionis.memory.taskStart({
  tenant_id: "default",
  scope: "docs-home",
  query_text: "fix flaky retry in worker.ts",
});

await aionis.handoff.store({
  tenant_id: "default",
  scope: "docs-home",
  anchor: "task:retry-fix",
  summary: "Pause after diagnosis",
  handoff_text: "Resume in src/worker.ts and patch retry handling.",
  target_files: ["src/worker.ts"],
  next_action: taskStart.first_action?.next_action ?? "Patch retry handling in src/worker.ts",
});

await aionis.memory.replay.run.start({
  tenant_id: "default",
  scope: "docs-home",
  actor: "docs-home",
  run_id: "retry-fix-run-1",
  goal: "fix flaky retry in worker.ts",
});

3. Optional: run the repository proof path

bash

npm run example:sdk:core-path

Default Product Path

Path	What To Prove	Primary Surfaces
Core	Continuity works at all	`memory.write(...)`, `memory.taskStart(...)` or `memory.planningContext(...)`, `handoff.store(...)`, `memory.replay.run.*`
Enhanced	Continuity improves over time	`memory.archive.rehydrate(...)`, `memory.nodes.activate(...)`, `memory.reviewPacks.`, `memory.sessions.`
Advanced	The runtime exposes deeper learning and control	`memory.experienceIntelligence(...)`, `memory.executionIntrospect(...)`, `memory.delegationRecords.`, `memory.tools.`, `memory.rules.`, `memory.patterns.`

Recommended order:

prove the Core path first
add the Enhanced path when reuse quality matters
move into the Advanced path only when your host needs deeper substrate controls

Fastest repository proof:

bash

npm run example:sdk:core-path

Aionis RuntimeSelf-evolving execution memory for agent systems.

Better task starts

Structured handoff

Replay that becomes reusable

Policy memory

Semantic forgetting

Typed runtime surface

Positioning

Design Principles

Execution first

Continuity first

Self-evolution first

Intelligent forgetting first

Core Capabilities

Action Retrieval And Uncertainty Layer

Self-Evolving Mechanism

Better second task start

Policy memory materialized

Governance loop proved

Provenance survived promotion

Session continuity promoted a stable workflow

Semantic forgetting cooled memory without deleting it

Forgetting Mechanism

Continuity Mechanism

Start better

Resume cleanly

Reuse successful work

Full Architecture

Benchmarks And Validation

Quick Start

1. Start Aionis Runtime

2. Integrate the SDK into your own project

3. Optional: run the repository proof path

Default Product Path

Read Next

Run Lite locally

Use the SDK

Read the architecture

Aionis RuntimeSelf-evolving execution memory for agent systems.

Better task starts

Structured handoff

Replay that becomes reusable

Policy memory

Semantic forgetting

Typed runtime surface

Positioning ​

Design Principles ​

Execution first

Continuity first

Self-evolution first

Intelligent forgetting first

Core Capabilities ​

Action Retrieval And Uncertainty Layer ​

Self-Evolving Mechanism ​

Better second task start

Policy memory materialized

Governance loop proved

Provenance survived promotion

Session continuity promoted a stable workflow

Semantic forgetting cooled memory without deleting it

Forgetting Mechanism ​

Continuity Mechanism ​

Start better

Resume cleanly

Reuse successful work

Full Architecture ​

Benchmarks And Validation ​

Quick Start ​

1. Start Aionis Runtime ​

2. Integrate the SDK into your own project ​

3. Optional: run the repository proof path ​

Default Product Path ​

Read Next ​

Run Lite locally

Use the SDK

Read the architecture

Positioning

Design Principles

Core Capabilities

Action Retrieval And Uncertainty Layer

Self-Evolving Mechanism

Forgetting Mechanism

Continuity Mechanism

Full Architecture

Benchmarks And Validation

Quick Start

1. Start Aionis Runtime

2. Integrate the SDK into your own project

3. Optional: run the repository proof path

Default Product Path

Read Next