You have the runtime. You have personas with lanes and journals. You have nets that build themselves on first contact. The next ceiling isn’t another transition kind or another persona it’s what you do with everything the runtime has already been recording without being asked.
Every fire of every transition, every token created, every property updated, every reservation taken and released all of it is in the event store. Most agentic systems treat their history as logs to grep when something breaks. In Agentic-Nets the event log is the same shape as the live state. That single property is what unlocks the patterns below.
The thing nobody is using yet: your event log is a corpus
Event sourcing in the runtime is not a backup format. It’s an immutable, append-only, fully-typed timeline of every state change in every model. createLeaf, updateProperty, deleteLeaf, ReserveLockEvent — each event has a parent, a name, properties, and a model version. Replay them in order and you reconstruct any place at any point in time.
That means the event log is not just storage. It is a training corpus the system maintains for free, with three load-bearing properties:
- Causally complete. Every token has a producer (the transition that emitted it) and a consumer (the transition that reserved it). The chain from final reply back through fusion, advisor, routing, user message is reconstructable without instrumentation.
- Schema-stable enough. Inscriptions evolve, but the JSON shape of tokens at any version is recoverable from the events that wrote them. You can ask “what did this place look like in week 1?” and get a real answer.
- Cheap to query. ArcQL plus a version filter is enough to pull historical token sets without rebuilding the whole tree. You can backtest a routing rule against last month’s traffic in a script, not a data pipeline.
That is the key. Most of what follows is “the corpus is already there — what should we do with it?”
Pattern 1: Crystallization — bend the cost curve down
The promise on the box was that AI handles novel work and patterns get crystallized into deterministic transitions over time. Today, crystallization is something you do by hand: you watch an agent transition for a few weeks, notice it always picks the same branch, and rewrite it as a map or a pass.
The event log makes this automatic. A scheduled organizer net can:
- Read the journal of every agent transition over the last N firings.
- Cluster the input tokens by shape and the output tokens by routing decision.
- Flag the transitions where one branch dominates > 95% over a stable window.
- Generate the equivalent
mapinscription, propose it as a draft transition next to the original, and run both in parallel for a week. - If the deterministic version stays in agreement with the agent on the next batch, hot-swap it in.
The cost curve doesn’t bend down by accident. It bends down because something is watching the journal and proposing the rewrite. Nothing else’s agent runtime does this — and nothing else has the corpus shape to do it cheaply.
Pattern 2: Token-level provenance + time-travel debugging
When an advisor gives a wrong answer today, the diagnostic loop is: read the chat log, guess what routed where, query the places by hand, hope the right tokens are still there. Half the time the tokens have been consumed and the trail is gone.
The event log already records every consumption. Every reply token has a producer transition. Every producer transition has a preset binding that names the input tokens it reserved. Walking backwards from a final reply to the original user message is a deterministic graph traversal — not detective work.
What this unlocks, once a UI exists for it:
- Click any reply, see the chain. User message → coordinator routing → advisor invocation → fusion → final. With timestamps, latencies, and the exact inscription value at the moment each transition fired.
- Change one routing rule and replay forward. Take last Tuesday’s traffic, mutate the routing inscription, replay against the same input tokens, compare answers. Backtesting for nets.
- Trust before deploy. Before promoting a new advisor prompt, replay it against the last 100 user questions and see whether any of them get worse. The corpus is the test set.
This isn’t a feature wishlist — it’s leverage from infrastructure already paid for. The event store exists, the version field exists, ArcQL with a version filter exists. What’s missing is the UI that walks the chain.
Pattern 3: A/B routing experiments — let the corpus decide
You change a routing rule. Did it actually improve anything? In most systems the answer is “we hope so.” In a net with a complete event log, you don’t have to hope.
Two parallel routing transitions, dispatched by a hash of the request id. Both feed the same downstream advisors. After a week, a scheduled scorer reads both branches’ final replies, computes a content-overlap or sentiment metric per request, and reports which routing rule produced more on-topic answers. The winner gets promoted; the loser gets retired.
Same shape works for advisor prompts, fusion templates, knowledge token shapes, anywhere there’s a structural choice you can fork. The event log gives you a metrics surface to score against; the parallel transitions give you a fork to compare; the scheduler gives you the cadence. Three primitives you already have.
Pattern 4: Net-of-nets composition
This one needs a new primitive — and it’s the one that turns Agentic-Nets from a runtime into a substrate.
Today, places hold tokens that are JSON. Imagine a place where each token is a handle to a whole sub-net — its session id, its current health, its inbox, its reply place. A parent net coordinates by passing sub-net handles around: “this conversation needs an agile-team — here’s a handle, here’s the goal, ping me on the handle’s reply place when you’re done.” The parent doesn’t know the sub-net’s internals. The sub-net doesn’t know who spawned it.
What this gives you that today’s “two nets share a place” pattern doesn’t:
- Lifecycle. Sub-nets can be spawned, monitored, paused, killed. The handle is the lifecycle interface.
- Encapsulation. The parent doesn’t address the sub-net’s places by name; it goes through the handle. Two instances of the same sub-net don’t collide.
- Composition without coupling. An agile-team net, a domain-expert net, and a publisher net can be assembled into a “research-and-write” net by a top-level coordinator that only knows handles.
And — bringing it back to the corpus — every sub-net spawn, every handle pass, every termination is just more events. The event log already absorbs hierarchy without changing.
Pattern 5: A cross-net signal bus
Today, when two nets need to coordinate, one net reads another net’s place by name. It works, but it’s coupling: net A has to know net B exists, has to know the place name, breaks when B is renamed. Multiply by a dozen nets and the topology becomes a wall of name dependencies.
A single global p-signals place changes that. Any net writes a typed signal token: “new email from finance team,” “user marked goal complete,” “weekly review starts in 5min.” Any net subscribes via a kind=link transition that filters by signal type. Producers don’t know consumers. Consumers don’t know producers. The bus is just a place.
This is the same shape that turned monoliths into event-driven services in the early 2010s. The difference is you don’t need Kafka — the place primitive plus link transitions plus ArcQL filters already give you exactly this, with the event log as the audit surface for free.
Pattern 6: Packaging — nets as artifacts
The reflexive advisor team. The agile coding team. The intel-gather platform. The domain-expert pattern. Each of these took real work to design, debug, and stabilize. Today they live as scripts and JSON files in someone’s repo.
The runtime already exposes PACKAGE_PUBLISH and PACKAGE_INSTALL tools in the agent toolkit. What’s missing is a published net: a versioned artifact containing places, transitions, inscriptions, knowledge seeds, schedule.yml, and a one-line install command. “Add a domain-expert to your model” becomes agenticos install domain-expert and you get a working persona on top of your existing nets.
That’s the leap from a runtime you build inside to a substrate you build on top of. And once nets are artifacts, the corpus turns into telemetry: “this packaged team has been installed on 14 models — here’s the failure modes that show up most often in their event logs.” Maintenance for free.
The thread
Five of these six patterns lean on one observation: the event log is the system’s memory of itself, and you’ve already paid for it. Crystallization reads the corpus to propose deterministic rewrites. Provenance walks the corpus backwards from any reply. A/B experiments score parallel branches against the corpus. Net-of-nets composes hierarchy on top of it. Packaging turns the corpus into telemetry across installations.
Only the sixth — the signal bus — is a structural addition. The other five are leverage on infrastructure that’s been quietly recording everything since day one. The work isn’t building more runtime. It’s building the things that read the runtime back.
Agentic-Nets stop being a runtime when they start optimizing themselves. The event log is how they get there.