SVIT_

Research-stage runtime designed for agents

Give the agent a space to remember, act, and evolve.

Svit keeps memory and executable behavior together in one structured, self-reflective space. Agents can inspect it, script it, and evolve it through bounded transactions.

Structured. Scriptable. Transactional. Self-reflective. Forkable.

Explore the process model Explore the source
process / counter COMMITTED · v4
ACTIVATION TRACE
01

LOAD

memory.count = 6
02

RUN

input.by = 3
03

COMMIT

memory.count = 9
output { count: 9 }
root   sha256:91e5…87a1
outbox 0 intents
ATOMIC TRANSITION18.2K / 100K TICKS

The premise

Memory and behavior belong in one coherent space.

A space the agent can understand from inside: structured state, discoverable scripts, bounded transitions, and explicit authority.

01 / Process model

Small enough to reason about.

One process. One committed root. One activation at a time.

01/memory

Own one memory tree

A process keeps bounded, serializable state that survives across activations and can be read by its scripts.

02main(input)

Run one activation

A named restricted-Lua script receives input and runs against a transactional working copy of the process state.

03v → v + 1

Commit as one change

Memory, staged scripts, and buffered message intents commit together. Any failure leaves the prior state untouched.

04sha256(root)

Snapshot or fork

Capture canonical committed state, restore it later, or fork an independently mutable child for another line of work.

02 / Transaction boundary

Success commits once. Failure commits nothing.

Each activation works on a private copy. Syntax, runtime, conversion, validation, and limit failures all roll back memory, scripts, outbox, and version together.

✓

The invariant
No partial process state escapes an activation.

03 / Guest boundary

No ambient authority.

Guest scripts get an explicit, versioned language surface—not the host operating system. Every activation starts in a fresh VM built from an allowlist.

This is a tested runtime layer, not proof of hostile same-process multi-tenancy. Production isolation still needs a Wasm or OS boundary.

VISIBLE TO GUEST

memoryinputscripts.list()scripts.read(name)scripts.save(name, source)log.info(message, fields)send(address, message)

ABSENT BY DEFAULT

  • ×filesystem
  • ×network
  • ×environment
  • ×process
  • ×clock
  • ×randomness
  • ×module loader
  • ×native extensions

04 / The smallest useful script

State in. State out.

A named script defines main(input). The runtime owns the transition around it.

counter.luaSVIT LUA 1
01  function main(input)
02    memory.count = memory.count + input.by
03
04    log.info("counter updated", {
05      count = memory.count
06    })
07
08    return { count = memory.count }
09  end
INPUT{ by: 3 }OUTPUT{ count: 9 }VERSION3 → 4
RUN THE EXECUTABLE EXAMPLEcargo run -p svit --example durable_counter↗

05 / From slice to system

Start with a kernel. Grow toward an agent runtime.

The current slice tests the core semantics. The larger direction adds projections, communication, identity, durable execution, and stronger isolation.

IMPLEMENTED NOW
  • ✓Transactional memory, scripts, and outbox intents
  • ✓Deterministic JSON snapshots with integrity hashes
  • ✓Restore and fork with isolated future mutations
  • ✓Fresh restricted-Lua VM for every activation
  • ✓Configurable execution, heap, value, and output limits
RESEARCH DIRECTION
  • —Project the outside world into the same structured value space
  • —Addressable communication between runtimes
  • —Runtime-native identity, authentication, and capabilities
  • —Durable storage, scheduling, and message delivery
  • —Stronger isolation through Wasm or OS process boundaries

Security claims track executable evidence. The repository includes a threat model, adversarial tests, and an explicit negative specification.

Open source · MIT licensed

Design the runtime
agents actually need.

View Svit on GitHub Read the vision