Long tasks lose the route
After compaction or a new session, the Agent needs the accepted plan, active path, and current constraints.
Aionis Runtime v0.3
Give your agent clean execution state
Aionis turns messy agent history into compact, governed execution memory: accepted routes, blocked alternatives, reusable procedures, rehydrate pointers, feedback evidence, and memory-use receipts that survive agents, threads, devices, sessions, and model switches.
connect throughSDK/APIMCPAIFSnative plugins
Why it exists
Retrieval finds similar text. Agents need execution state.
Long-running Agents need governed state they can act on.
Aionis keeps current execution state, ordinary memory, feedback evidence, and blocked history separate before the next prompt is compiled, so the Agent resumes from the state that actually survived.
Relevant memories can mislead
Old execution evidence can look semantically relevant even when it is stale, failed, or from another scope.
Teams need an audit trail
When an Agent acts, operators need to know which memories shaped it, what was ignored, and what outcome followed.
Product loop
Wrap the Agent loop, keep the state boundary.
Add four runtime calls around the loop you already have. The Agent still writes code, searches, tests, and decides. Aionis records execution state, compiles the next context, attributes outcomes, and leaves receipts.
host -> POST /v1/observerecorded plan, tool calls, target files, verifier output, and branch decisions
host -> POST /v1/guidecompiled agent_context: current route, blocked alternatives, payload hooks, receipts
agent acts -> host -> POST /v1/feedbackattributed which memories were used and which branches stayed inactive
host -> POST /v1/measure + /v1/operator/snapshotwrote memory-decision receipt and training-ready admission rows
execution memory
Current route, targets, and acceptance checks.
Influence, source, reason, and outcome.
Large payloads stay behind precise restore pointers.
Stale or low-authority history stays evidence-only.
AIONISstate runtime117k raw history -> 28k governed context
active_state
Current route enters the next prompt.
review_queue
Unknown, contested, or weak evidence stays visible but gated.
blocked_branch
Outdated, invalidated, or low-authority context is retained as evidence without becoming instruction.
payload_hook
Pointer-only history can be restored without flooding the prompt.
agent receives
active_state
continue from governed state
The agent acts from governed state instead of rereading every trace.
current routeblocked alternativesrehydrate hooksdecision trace
Before / After
Compress history without losing state.
Aionis keeps the execution state a capable model needs, while removing the raw context mass that makes long-horizon agents slower, noisier, and harder to audit.
Full history enters117k
117k full-history promptOld evidence appears relevantStale target competes with current routeAgent must rediscover what happened
AIONISstate compiler
preserve state · remove prompt noise · keep raw hooks
Aionis context exits28k
active_routeaccepted state ready for the next agent
failed_branchinvalidated route retained as counter-evidence
payload_hookraw evidence available only when requested
receiptmemory influence remains auditable
76.1%smaller prompt context
117k full history → 28k governed context
Benchmarks
Continuation quality with less prompt mass.
Aionis keeps the agent on executable state while cutting prompt context and preserving audit surfaces. The 40-case external Agent E2E compares Aionis with Full History, BM25, and Mem0.
External Agent E2E · 40 continuationsAionis matched 100% completion with the lowest total tokens.
Full reportArmCompletionPrompt tokensTotal tokensRead
Full History97.5%1,684,5671,821,808Strong but expensive
BM25100%651,377802,620Lean retrieval
Mem0100%1,096,7381,248,053Memory baseline
Aionis100%650,482794,196Governed context
Aionis used 61.4% fewer prompt tokens than Full History and 40.7% fewer than Mem0 while preserving 100% continuation completion.
83.0%
Buried histories
100% completion with 83.0% fewer prompt tokens than Full History.
Open evidence40/40MGBench
Product-positive with 0/40 unsafe direct-use, 100% rehydrate recall, and 100% trace coverage.
Open evidence76.9%State-preserving compression
0% stale leak, 100% rehydrate, 100% audit, and 95.8% downstream action accuracy.
Open evidenceSolutions
Where Aionis becomes useful first.
These are product scenarios, not installation channels. Aionis sits around the agent loop and turns memory into governed execution context.
Solution 01
Coding Agent Execution Memory
Preserve plans, target files, acceptance checks, validation output, and handoff state across coding sessions and compaction.
Solution 02
State-Preserving Context Compression
Replace raw transcript transfer with compact governed context: current state, blocked evidence, and rehydrate pointers.
Solution 03
Multi-Agent Handoff
Carry the same execution state from planner to worker to verifier to reviewer without copying every historical token.
Solution 04
Memory Firewall
Let Mem0, Zep, Supermemory, Chroma, pgvector, logs, or internal stores retrieve candidates, then govern admission before prompt influence.
Solution 05
Agent Flight Recorder
Replay what memory the agent could see, what was blocked, why it was routed, and what outcome followed.
Solution 06
Trace-Derived Skill Memory
Turn successful traces into reviewable procedure candidates instead of silently promoting every summary into memory.
How it works · Spec sheet
Aionis supplies the execution-memory boundary around your agent loop.
Your agent keeps planning, tool use, validation, and permissions. Aionis governs what enters context, what stays gated, what can be restored, and what evidence should be logged.
Agent host
Claude Code, Codex, custom workers, MCP tools, or any loop that can call observe, guide, feedback, and measure.
- SDK/API
- CLI
- MCP bridge
Aionis Runtime
Compiles governed agent_context from execution traces, ordinary memory, feedback records, and lifecycle relations.
- Lite runtime
- SQLite
- Decision trace
Memory substrate
Keeps append-only evidence while changing whether history can directly influence the next Agent turn.
- execution memory
- ordinary memory
- relation graph
Audit and learning
Exports receipts, snapshots, admission rows, and trace-derived candidates so memory influence can be measured.
- Flight Recorder
- MGBench
- skill candidates
Install
Install once. Connect any Agent loop.
Start with one command, then call the Runtime from your host. MCP is available for coding tools, but the core product path is still the Runtime API and SDK.
aionis-runtime
$ npx aionis setup$ choose openai or minimax and paste your embedding key$ cd .aionis-runtime && npm run -s lite:start$ connect with SDK, HTTP, MCP, AIFS, or pluginFAQ
Quick answers.
Install the Runtime, connect the SDK/API, and let Aionis own the memory boundary around your Agent loop.
What does Aionis do?
It records execution evidence, ordinary memory, handoffs, and feedback, then compiles a compact state object for the next Agent turn.
How do I add it to my Agent?
Install the Runtime, call observe as work happens, call guide before the next Agent turn, and report feedback after the outcome.
Where does MCP fit?
MCP is the fastest zero-code bridge for tools like Claude Code, Cursor, and Codex. It is one access path, while SDK/API is the main product integration path.
Why use it with existing memory systems?
Retrieval systems find candidates. Aionis adds lifecycle, authority, scope, feedback attribution, and audit before those candidates affect the Agent.
Give your agents cleaner execution context.
Install the Runtime, wire the SDK/API, and put an auditable memory boundary around your Agent workflow.