It updates when something happens.
AnantState is built around events: a payment, a sensor reading, a case update. Each one is matched to the thing it belongs to, and that thing’s condition is updated using the real time that has passed since its last event. Nothing waits for a nightly batch.
In plain termsEach event updates the picture as it arrives.
At a glance
Streaming first
A live stream advances entity state in real time.
Real elapsed time
Irregular and silent feeds are handled.
Failures stay visible
A dead-letter view holds what could not be mapped.
Batch is supported too
Backfill and warehouse pulls land as events in the same path.
From event to decision
An event arrives
From a stream, an HTTP source, a scheduled pull or a bulk import. Every route attributes the event to a domain and maps it to an entity.
State advances by real elapsed time
The platform recovers the observed time between an entity’s events from its timestamps and advances state by that amount. A store that reports every 200 ms and a supplier that reports daily are handled by the same engine.
Divergence is visible immediately
The gap between predicted and observed state is recomputed as state moves, so an early warning comes from the stream, not a nightly job.
A decision opens, priced
The forward position, the candidate actions with their costs, and the evidence arrive together. Nothing happens without a named actor or a granted authority.
Every route lands as an event
| Route | Use when |
|---|---|
| Streaming | You have a live event stream and want entity state to advance in real time |
| REST source | A system can push, or be polled, over HTTP |
| Scheduled pull | A warehouse or batch system holds the history and latency is acceptable |
| File or bulk import | Backfilling a population to stand up a new domain |
So the live path is event-driven end to end, and history arrives by the same door. See integrations for the connector catalog.
Every route lands as an event
- Streaming: A live stream; state advances in real timeLeads to: An event
- REST source: A system can push, or be polled, over HTTPLeads to: An event
- Scheduled pull: A warehouse or batch system holds the historyLeads to: An event
- File or bulk import: Backfilling a population for a new domainLeads to: An event
- An event: Attributed to a domain, mapped to an entityLeads to: State update; Dead-letter view (could not be mapped)
- State update
- Dead-letter view: What could not be mapped, with the reason
- Keyqueue: Where every route converges; cylinder: Stored state; external: Kept in view, not lost
Silence is an event too
A device that has stopped reporting is, in most monitoring, indistinguishable from one reporting healthy values. In a state model, silence is a divergence the model can see. When a gap exceeds the ceiling the model was trained on, the engine falls back to a documented path rather than extrapolating, because extrapolating across a silent entity produces a confident number with no information in it.
Failure is visible, not silent
- A dead-letter view holds events that could not be mapped, with the reason, so a mapping bug shows up as a visible backlog rather than as missing data.
- Rate limits and notification limits are configured controls, so a flood cannot become a flood of alerts.
- Cross-domain bridges are acyclic and rate-limited, so a cascade has a defined end and a bounded cost.
Show us the stream
Tell us where your events live and how they arrive. We will map one domain onto them and show state advancing on your data.