Neumera

System Updates

Neumera is not a static product surface. It is a live system substrate that is becoming more capable over time. This page tracks meaningful changes in what the system can sustain, expose, and support — across continuity, worlds, governance, evidence, coordination, and builder access.

Current public system

Core runtime and continuity

Persistent sessions now carry real operational continuity

Neumera’s session model now supports a clearer continuity thread across time. A live system can remain attached to the same obligation instead of being rebuilt from scratch on every interaction.

  • session state can persist across multiple steps
  • continuity surfaces expose what remained live and what changed
  • development signals now help reveal how repeated use alters the run

Why it matters This is the threshold between one-shot response and durable responsibility.

Continuity is now easier to inspect

Runtime continuity, development, and summary surfaces have been strengthened so builders can inspect not only what a system produced, but how it remained the same system while moving through change.

  • stronger runtime summary surfaces
  • clearer continuity readouts
  • improved development-facing signals for repeated use

Why it matters Persistence only matters if it can also be observed.

Recent surface expansions

Worlds, evidence, and governance

World state is now a first-class operational surface

Tasks, objects, histories, and changing conditions can now be carried as live world state rather than being reintroduced as disconnected prompt context.

  • world state and object surfaces now support richer inspection
  • world history is easier to traverse
  • object and relationship reads now make long-lived references more legible

Why it matters A system cannot remain grounded if the world disappears between turns.

External events now propagate through repairable world change

External event ingress has become a stronger public surface. A live thread can now absorb a world change, expose invalidation or disruption, and continue through repair without losing the same underlying task or context.

  • external events can be ingested directly
  • history and reconciliation surfaces now show more of the transition path
  • repair-aware world continuation is easier to inspect

Why it matters This is where continuity stops being memory and becomes adaptation under real conditions.

Evidence surfaces now support stronger replay and trust

The evidence model has been strengthened so that public runs can be inspected through route history, payloads, dossiers, and supporting records rather than only through summaries or claims.

  • dossier and artifact flows support deeper inspection
  • route-level evidence can now be surfaced more cleanly
  • system claims are easier to trace back to inspectable records

Why it matters A system that changes over time must leave evidence that survives the explanation of that change.

Governance remains attached to the live system, not added later

Governance is being exposed more clearly as part of the same live stack: action, review, evidence, and bounded continuation all remain tied to the same operational thread.

  • reviewable surfaces are easier to connect to live state
  • history and evidence remain available after operational change
  • governance is treated as part of the runtime world, not as an external wrapper

Why it matters Persistent systems need constraints that persist with them.

Now visible in Studio and the public API

Shared coordination and public surface

Shared contexts now support direct public coordination flows

Shared contexts have become a stronger public surface for multi-entity coordination. Persistent participants can now be attached to the same live context, and commitments, disagreement, repair, and reconciliation can remain inside one shared state.

  • shared contexts can now be created directly
  • participants can be attached and removed through public routes
  • coordination mutations now support proposal, disagreement, repair, and alignment flows

Why it matters Coordination becomes much more real when it is carried as shared state instead of hidden inside messages.

Chronology and causal linkage are becoming clearer

Public route payloads now expose stronger summaries of what changed, what caused it, and what the latest meaningful transition was. This reduces the amount of client-side reconstruction needed to understand a live run.

  • write surfaces expose stronger summaries
  • read surfaces now carry clearer transition markers
  • cause-and-effect is more visible across sessions, worlds, events, and shared contexts

Why it matters A system that evolves needs a chronology that can be read, not just recorded.

Studio now functions as a public reference environment

Studio has become a public surface for witnessing live examples of continuity, world perturbation, and multi-entity coordination. It is not a mockup layer; it is a reference environment built on the same public API surfaces available to external builders.

  • live examples now run against the public API
  • scenario evidence is inspectable
  • Studio increasingly serves as a builder-legible reference surface, not a decorative demo

Why it matters The best proof of a new substrate is that it can be used to make itself legible.

The public builder surface is becoming more coherent

Start Building, Quickstart, workflows, starter implementations, and reference surfaces are being tightened so builders can move from concept to live system more directly.

  • docs entry points are clearer
  • starter paths are more practical
  • reference flows are easier to follow from idea to implementation

Why it matters A system this new has to be explainable not only as theory, but as a path into practice.

See it in practice

Review the Architecture · Enter Studio · Start Building