Modeling the Enterprise World

The enterprise has never been more instrumented. Every action is logged, and all data is stored in some source, making workflows with previous blindspots have transparency and visibility at every step. And yet, despite massive gains in model reasoning, returns on enterprise automation have not materialized.

Automation has been promised since GPT-3. The initial years of AI developed under a simple lemma: more compute, better models, more automated work. Yet, this is the central paradox. More compute, better models, complete logged data, and the promise of automation is still unachieved.

Why are agents still failing in the enterprise?

The limitation is not reasoning. Agents are becoming increasingly proficient in general predictive tasks like coding, writing, and tooling. But enterprise workflows are not isolated tasks. Actions taken live in the evolving state of data across fragmented environment-specific sources and interactions over time. Not only has the reasoning model never seen the workflow, the workflow itself is not represented in a way that the model can access or learn from.

The AI automation promise is misguided, and will continue to be broken. The modern bottleneck for enterprise automation is no longer model capability, but the ability to structure and persist workflow state.

A narrow class of workflows, those that are standardized and done by the masses, are now accessible to consumers and prosumers. These can easily be automated with OpenClaw, coding agents, etc. with relatively good performance. They also correspond cleanly with the capabilities of models with well-defined inputs and outputs.

The remaining majority are fundamentally different and concentrated at the enterprise level. Not only do these workflows not correspond to model capabilities (because of their private nature), the workflows themselves are fragmented across extremely nuanced systems. These workflows are also highly dependent on the connected state of these systems. Even if models had the capability to operate on them, the problem then relies on structuring this state into a reliable agent input.

Workflows at the enterprise level are not stateless tasks. You cannot just observe a static snapshot in time and make a decision. Decision-making requires being conditioned on a dynamic state.

This state is non-trivial to represent. Not only must it represent complex enterprise data in a universal way, but it must also model how the data has changed and evolved over time. Not only who did what, but under what conditions - and from this, how these conditions should be represented to decide what happens next.

Today, there does not exist a version of this state. Enterprise data remains fragmented across different systems, each with different schemas and conditions that do not canonicalize universally. The data is model-agnostic, distributed, and constantly evolving, and there is no unified representation of it.

Resulting from this, enterprise systems are non-compounding: context is effectively disposable and non-operational.

The gap becomes clear when looking at how workflows can currently be captured.

There is a difference between a log of actions and a stateful workflow.

Take an IT triage workflow. A ticket is not just created and then later resolved. There is much nuance during its inception and evolution. It gets assigned to a junior engineer, who previously was cited for poor debugging skills in a performance review. Their attempt fails, and the ticket is escalated. Ownership changes. Constraints from internal policies and rate limits emerge. These are considered, and the approach is successful. Each action depends on all the context created and involved by all previous actions.

You can capture the telemetry of individual events: the IT ticket being created, the attempt failing, ownership changing, and the attempt succeeding. But if you cannot capture the complete context in which those events occurred, and how they connect to form the specific workflow as a whole, then you do not have more than a log.

Current attempts to address this fall into 2 buckets in which "memory" is being built, and neither succeeds at creating a stateful representation of context.

Retrieval-first solutions

Many tools treat the memory layer as an extension of search. The rudimentary approach boils down to the following: use reasoning to extract facts from data, embed and store the facts, retrieve the facts at inference time.

The approach relies on approximate matching over highly specific data, giving no attempt at completeness or correctness. At the enterprise level, where workflows are increasingly complex, these systems clumsily degrade. On tasks that require surfacing events or facts that have updated, or data with temporal relationships, these approaches degrade.

"Bitter-lesson-pilled" solutions

These solutions aim to create a structure of knowledge that requires more compute at scale. These include file-system memory and agentic search.

In pursuit of paid inefficiency, these approaches lose all notions of "state". On top of the seconds of inference time required upon search, the representation of data can maintain no provenance, no lineage, no derivations, and no usable state. They constantly write to multiple sources of truth, with no metadata or additional context remedying this, making them nearly impossible to audit at scale.

In a sensitive environment like the enterprise, this sort of representation is unacceptable. Decisions require having a principled state of data, where information is traceable and consistent. These compute-heavy approaches cannot provide this.

Memory is not the underlying problem, but the absence of a state layer is. As agents move from standardized tasks into real workflow settings, these above limitations are no longer theoretical, but rather the defining bottleneck for automation.

The missing piece is a system of state.

Our first product, Nebula, is built around this thesis. The first component is a stateful memory architecture. In order to achieve this, Nebula decomposes unstructured data, documents, conversations, system events, user actions, and other data sources into a typed hierarchical vector graph. There are three horizontal layers of abstraction done to create compounding knowledge: semantic, episodic, and procedural context. The structure allows knowledge to compound beyond the entity-relationship level.

At the same time, Nebula maintains an explicit, queryable representation of what is true, when it became true, and why we believe it, articulated via lineage. This allows for the graph to act as the principal substrate that other systems can interact with. Every state change is auditable and composable, so context accumulates coherently across months of operation instead of being re-derived from raw text on every call.

The result is a platform where automation compounds. Each interaction hydrates the graph, making every successive consumer, whether agent, artifact, or human, more capable. This is the missing primitive the current generation of AI infrastructure lacks, and it is the foundation on which durable enterprise workflows will be built.

The state layer is valuable in its own right. But its deeper implication is what it makes possible for the first time: a class of model behavior that has been theoretically desirable but practically unachievable. The prior limitation to this behavior was that the underlying data required to support it has never existed in a structured form.

We call the method to achieve this behavior Memory Models. Prior attempts at continuous learning in agent systems have failed not only in part because the methods were wrong, but because the training signal was underdeveloped. Prior, agent "traces" could capture what was done, and what the outcome was as a result. The full context surrounding each decision was lost, and without that, conditioning a model on traces produces a model that learns actions, not intuitive judgment.

Nebula's state layer changes this. Because workflows can now be fully structured, traces can carry meaningful training signals. This creates two behaviors that are currently impossible: continuous learning where models are conditioned on structured traces and improve directly from operational experience, and proactive surfacing where shifts in workflow state predictively trigger the right agent action before a human intervenes. Together, these close the loop on autonomous enterprise automation. Memory Models represent Nebula's long-term research direction, and the state layer is the necessary foundation on which they are built.

Every system that will perform context work depends on state. Today that state is implicit and fragmented. Nebula makes it real: a single, structured representation of what is true, when it became true, and why.

Once that representation exists, everything converges on it. Workflows, agents, analytics, and human decisions stop operating on private, incompatible snapshots and start operating on the same layer. An action taken by one agent becomes context the next one can reason over. A decision made today becomes a trace a model learns from tomorrow. Knowledge stops being disposable and starts becoming usable.

This is the layer the next generation of automation will be built on, not because anyone declares it so, but because stateful work has nowhere else to live. We're building it to be that foundation: a primitive others can build on, principled enough to trust, shared across every system that touches enterprise context.

The bottleneck was never reasoning. It was that the stateful world had no representation of its state. We're giving it one.