Machine Intelligence Engineer / Software Architect

Persistent AI memory with clear boundaries between local continuity and runtime coordination.

Michael Kappel’s AI-memory work separates two problems that are often blurred together: UAIX/.uai provides typed local startup and handoff continuity for a repository or project, while Multi-Agent Memory provides a shared runtime layer designed for registered external agents. One preserves context across sessions; the other adds coordination and shared services.

Review the .uai handoff Open UAIX.org Compare runtime coordination

Fast recruiter summary

Two memory lanes, two different responsibilities.

The separation prevents a local handoff package from being mistaken for a live multi-agent platform.

Lane 1 / UAIX and .uai

Typed local startup and handoff continuity.

Repository-local files preserve identity, purpose, constraints, active state, source authority, coding expectations, recovery notes, and next-step handoff information for a future session or agent.

Lane 2 / Multi-Agent Memory

Shared runtime memory and coordination.

A deployable private-intranet reference system adds registered identities, organizational scopes, claims, leases, message routing, acknowledgements, durable records, search, synchronization, and human verification.

Engineering value

Continuity without hidden authority.

Both lanes keep source status, scope, lifecycle, and review visible so remembered context can assist work without silently becoming unquestioned truth.

Local continuity diagram

How a .uai package carries project state across sessions.

This is a file-based startup and handoff flow. It is deliberately not presented as a message bus or orchestrator.

1. Startup indexA compact entry point identifies the reading order and authoritative project sources.
2. Identity and purposeRole, project intent, positive anchors, and hard boundaries define the local operating context.
3. Active memoryShort-term state records current facts, decisions, open work, and evidence still awaiting review.
4. Engineering constraintsCoding standards, source authority, test requirements, and safety rules constrain implementation.
5. File and project handoffChanged surfaces, recovery details, next actions, and validation state support a clean continuation.
6. Next sessionA future human or agent rehydrates bounded context without depending on the original chat transcript.

Memory design principles

Durability is useful only when provenance and review survive with it.

The architecture treats memory as governed project state, not a free-form accumulation of model output.

Typed responsibilities

Identity, world context, constraints, short-term state, file handoff, project handoff, and long-term pointers live in distinct records with distinct jobs.

Source authority

The memory points back to code, approved documents, tests, registries, and human decisions rather than replacing those sources.

Lifecycle awareness

Current, proposed, reviewed, sensitive, superseded, and archival material can be handled differently instead of flattened into one retrieval pool.

Compact startup

A deliberate reading order restores the smallest useful working set first, then routes deeper only when a task requires it.

Recovery orientation

Handoff records capture what changed, what was verified, what remains open, and how a future operator can resume safely.

Human governance

Memory can inform work, but publication, operational changes, stronger claims, and sensitive decisions retain explicit review gates.

Evidence path

Inspect local continuity and shared runtime memory separately.

Each link answers a different reviewer question.

What is the public memory manifest?

uai-memory-manifest.json provides a machine-readable public view of active handoff files and their roles.

What adds live coordination?

Multi-Agent Memory supplies the source-available shared runtime reference implementation.

Explicit non-claims

A .uai package does not itself orchestrate or message agents.

UAIX/.uai is typed local startup and handoff continuity. By itself it is not a scheduler, live message broker, shared database, execution engine, or proof that multiple agents are concurrently active. It also does not make remembered content true: sources, lifecycle labels, tests, and human review remain authoritative. Runtime coordination claims belong to the separately evidenced Multi-Agent Memory implementation.

FAQ

Common review questions.

Short answers are rendered in the HTML source and mirrored into JSON-LD where appropriate.

How do .uai files and Multi-Agent Memory differ?

Typed .uai files preserve local startup, identity, constraints, handoff, and recovery context. Multi-Agent Memory adds authenticated, scoped, reviewed shared memory and coordination for external agents.

Does .uai provide runtime orchestration?

No. .uai is a portable continuity and handoff model; it does not provide hosted messaging, automatic synchronization, repository writes, or agent certification.

How is memory governed?

Memory remains source-bounded and review-aware, with explicit status, scope, promotion, rejection, quarantine, readback, and human verification paths.