A shared state layer for agentic systems

Your agents share a task.
Do they share reality?

When agents, workflows and people act on the same case, scattered context creates conflicting updates and unclear ownership. LulaEdge gives them a shared operational state to work from.

See the live simulation Discuss an early use case
Shared entity state·Controlled changes·Event history
One operational entity
Customer incident · INC-849
Shared state
◉
Support
Triage
◇
Risk agent
Assess
◎
Human
Approve
◈LulaEdge
State + rules
status"triaging"
owner"support_agent"
risk_score95
versionv2
Proposals are checked before accepted changesevent → policy → commit
The coordination gap

More agents can mean more ways to lose track of the truth.

Orchestration can decide what runs next. It does not automatically give every actor a consistent, governed view of the business entity they are changing.

↔

Conflicting updates

Two actors act on stale state and produce incompatible outcomes.

⌁

Unclear ownership

It is hard to tell who is allowed to change a field, or who should act next.

≋

Fragmented history

Decisions and attempted changes are scattered across logs, prompts and tools.

!

The missing piece is not another agent. It is a shared, durable representation of the work—with rules for how it can change.

How LulaEdge works

One living entity. Multiple actors. Governed changes.

LulaEdge is designed to keep operational state explicit as agents and people collaborate on a process.

01 / REPRESENT

Model the work as an entity

A case, incident, order or customer has structured state that persists beyond an individual prompt or agent run.

02 / GOVERN

Check proposed changes

Use explicit ownership and policy boundaries to decide which actor can change which parts of the entity.

03 / TRACE

Keep a change history

Make accepted updates—and rejected attempts—easier to understand, inspect and debug.

Interactive concept demo

See a conflicting change get rejected.

A simplified simulation of a shared incident entity. Run each step to see how a policy can protect state from an unauthorized update.

● AUTO-PLAY ON

Incident entity

Open
entity / incident-849.json
{
"status": "open",
"owner": null,
"risk_score": 22,
"version": 1
}
CHOOSE AN EVENT

Illustrative product concept—not a live backend or a security guarantee.

Event history

LOCAL SIMULATION
SYSTEM
Simulation ready. Select an event to begin.
↳
State is waiting for an actor

The entity begins with no owner and a low risk score. Events will update the state only when accepted by this demo's rules.

A layer, not another agent

Keep your agents. Give their work a shared place to live.

LulaEdge is intended to complement your existing models, agents and orchestration tools—not replace the systems that make them think or decide what to run.

✓Use a persistent entity as the operational reference point.
✓Separate proposed changes from accepted state transitions.
✓Connect agents, workflows and human actions around the same entity.
Conceptual APITYPESCRIPT
const incident = await lula.entity.get(
  "incident-849"
);

// Propose a change, don't assume it commits
const result = await incident.propose({
  status: "under_review",
  risk_score: 95
});

if (result.accepted) {
  await incident.subscribe();
}
Illustrative interface to communicate the model; API is not represented as production-ready.
Help shape the next layer

When multiple actors change the same thing, what keeps the truth consistent?

We're validating where a shared operational state layer can make agentic systems safer to coordinate and easier to reason about.

Discuss your use case

Early-stage concept · Feedback and design partners welcome