Logos: An Agent Harness on a Cross-Process Bus

Research Paper Track

AAMAS 2027, 3–7 May 2027, Hanoi, Vietnam

Logos: An Agent Harness on a Cross-Process Bus Hanzhang Jia, Liheng Zeng, Hao Cheng, Yi Gao, and Bo Ma

arXiv:2608.28553v1 [cs.AI] 28 Aug 2026

University of Sussex Brighton, United Kingdom Zhejiang Gongshang University Hangzhou, China Shanghai Shuyuan Information Technology Co., Ltd. Shanghai, China hj303@sussex.ac.uk

Abstract

calculus [7]. In that calculus, a capability is a component carrying a tracked inverse, assembly applies an effect, removal applies the Modern agent systems assemble capabilities at runtime, and this recorded inverse, and an agent is assembled from such components dynamic composition has recently received a complete formal treatas plugins, with every record of assembly and removal kept in one ment in the spatiotemporal-composability calculus, in which a cashared context. The calculus proves a reversibility guarantee, and pability is a component carrying a tracked inverse, and agents are the guarantee is complete within a single-process implementation. assembled as plugins. This plugin form is carried by a single proHowever, that one process carries all plugins, all records, and all cess sharing one context, a carrier that places all components in sessions, so the process is a single point of failure for everything one physical failure domain, a fault suspends every component at it hosts. once, and process death interrupts every session the process hosts. Hosting all plugins in one process incurs four engineering costs. This paper shows that neither the modeling nor the calculus binds A physical fault in the hosting process, a crash, memory exhausan agent to one process, the statelessness of the language model tion, or a blocked event loop, terminates all components at once, keeps all cross-step state outside the model, and the soundness the withdrawal of one service unloads its dependents and renders invariant is defined on the state space alone. These observations the tools they provide unavailable to the model until reload, so condense into four lemmas whose premises are the hypotheses the isolation that holds between components in the mathematics of the calculus and the statelessness of language-model inference. loses its meaning inside a shared process. The death of the proOn these lemmas this paper constructs Logos, a ROS-like crosscess terminates every component and every co-resident session process agent harness in which a plugin is a process and the only at once, and recovery restarts the whole stack. Replacing or upshared state is an append-only transcript. Eighty sessions resume grading one plugin requires a process restart or a reload that tears with no repeated effect after kills placed at the four boundaries down and re-runs every dependent, and every co-resident session of the tool-call cycle, and a same-fault comparison with a singlehalts with the restart. The process is also a single-language enviprocess reference configuration shows one fault interrupting every ronment, in which plugins are confined to the host language and co-resident session while under the peer-process construction one cross-language reuse goes through translation layers and remote fault ends at one node. calls. Together, these four costs point to plugin composition across processes. Keywords For these problems, this paper presents four lemmas. Lemma LLM agents, agent infrastructure, distributed systems, hot swap1, orchestration externality, asserts that each forward pass of the ping, fault tolerance, composability model is a stateless pure map, that cross-step state already lives ACM Reference Format: outside the model, and that the input can be synthesized anywhere. Hanzhang Jia, Liheng Zeng, Hao Cheng, Yi Gao, and Bo Ma. 2027. Logos: On this basis, Lemma 2, carrier substitution, allows state to move to An Agent Harness on a Cross-Process Bus. In Proc. of the 26th International any persistent carrier, and recovery rebuilt from the carrier equals Conference on Autonomous Agents and Multiagent Systems (AAMAS 2027), in-place recovery under observational equivalence. Lemma 3, reHanoi, Vietnam, 3–7 May 2027, IFAAMAS, 10 pages. covery localization, draws on the calculus’s assumption of component independence and asserts that the recovery of each compo1 Introduction nent needs no coordination with any other. Finally, Lemma 4, exModern agent systems assemble capabilities at runtime, loading ternal resolution, moves dependency resolution out of the process and unloading components with their effects fully reverted, and as well, into a table keyed by capability name. The four lemmas rest this dynamic composition of software components has recently reon nothing beyond the assumptions the calculus already states and ceived a complete formal treatment in the spatiotemporal-composability the fact that language-model inference is stateless, adding no new mathematical hypotheses. It follows that spatiotemporal composThis work is licensed under a Creative Commons Attribution Interability holds across processes. Considering the design freedom of national 4.0 License. complex systems and the plugin form, this paper therefore selects the ROS architecture [6] as its basis and constructs Logos, a disProc. of the 26th International Conference on Autonomous Agents and Multiagent Systems (AAMAS 2027), M. Baldoni, F. Fang, W. Yeoh, N. Yorke-Smith (eds.), 3–7 May 2027, tributed plugin-based system. The system runs as a set of peer proHanoi, Vietnam. © 2027 International Foundation for Autonomous Agents and Multicesses on a bus. A harness runs the loop of input synthesis, model agent Systems (www.ifaamas.org).

Research Paper Track

calls, and output settlement over one session. A tool provides a capability. The router registers nodes and forwards messages by recipient. A node is any process that conforms to the protocol, and anything the rules admit mounts as a peer. In Logos a plugin is a process, the router holds only its routing table, and all shared state lives in an append-only transcript owned by no process. The transcript records every step of a session as it happens, and after any process dies, a new process rebuilds the session from the transcript and continues, a form of recovery called cold switching. Logos itself also removes the language cost, with a Go router, Python harnesses and tools, and Node.js tools running as peers on the same bus. Runtime verification shows that Logos passes messages without loss, duplication, or reordering, keeps one registrar per capability name, and delivers supply-change notifications in order, establishing the engineering feasibility of the distributed architecture, and a stress audit exercises each condition directly, with 3,500 calls from as many as two hundred concurrent callers pair with no loss, duplication, or misattribution, one registration wins among one hundred simultaneous claims of the same name with ninety-nine explicit denials, and two observers record identical supply-change sequences across thirty rounds of churn among fifty providers. In concurrent multi-agent scenarios, routing restores automatically after the router is killed, and the tasks of the harnesses complete as usual. Twelve end-to-end sessions undergo six process kills, all resume through cold switching, and no previously executed action is repeated after recovery. Eighty further sessions extend the coverage to four kill points of the tool-call cycle, during tool execution, after return but before persistence, after persistence but before announcement, and after announcement. All eighty resume and complete with no repeated effect, and the work redone after recovery equals exactly the work the transcript had not yet recorded. A tool comes online during a task, and the model makes its first autonomous call 8.4 s after the registry-update broadcast. The median cost of a bus hop is 0.215 ms, 1/823 of the model’s 177 ms first-token latency, invisible at the model’s time scale. Existing distributed architectures move actions across processes, MCP and its derivatives move tool servers out of the process, and Temporal and its peers move execution out of the process, while composition and assembly remain in the host [2, 8]. Logos moves composition and assembly themselves out of the process, carried by registration and broadcast among peer nodes. In summary, this paper makes three contributions.

• The sufficient conditions, Theorem 1, under which the reversibility guarantee of the spatiotemporal-composability calculus holds across processes, with the four supporting lemmas, with premises drawn from the calculus itself and the statelessness of language-model inference, stated in Section 4. • The minimal construction of Logos, a cross-process agent harness built on the ROS architecture, in which a plugin is a process and the only shared state is an append-only transcript, constructed in Section 5. • Adversarial and end-to-end evaluation of the fully implemented system, covering concurrent recovery under router failure, cold-switch resumption after process termination,

AAMAS 2027, 3–7 May 2027, Hanoi, Vietnam

Table 1: What each framework moves out of the process, and what stays in it. Framework

Moves out of the process

MCP and its derivatives Temporal and its peers AutoGen and LangGraph Logos

tool servers and calls

Stays in the process

composition and session state execution assembly and the workflow definition nothing all capabilities as inprocess objects composition and assem- nothing but the routing bly, state into the tran- table script

autonomous adoption of tools introduced during a task, and mixed-language operation on one bus, measured in Section 6.

2 Related Work In-process agent frameworks make the capability a library object inside the host that imports it. AutoGen organizes capabilities through conversation programming [9], and LangGraph organizes them through state graphs [3], both as in-process objects. Logos, in contrast, gives each capability its own operating-system process and places composition on the bus. Existing distributed architectures move actions across processes. MCP and its derivatives move tool servers out of the process, with calls crossing processes while composition remains in the host, which holds session state [2]. Temporal and its peers move execution out of the process, with assembly remaining in the workflow definition and recovery delivered through history replay [8]. Table 1 lines up the four frameworks by what each moves out of the process and what stays in it. The architectural lineage is the robot operating system, whose peer-to-peer processes and name-based routing this construction inherits [6]. The spatiotemporal-composability calculus takes plugin assembly as its subject and proves a reversibility guarantee in a single-process reference [7]. This work takes that treatment as its starting point and extends it to a multi-process carrier with sufficient conditions, a construction, and measurements. Two parallel preprints study adjacent questions of agent state and history [4, 5]. Neither examines cross-process reversibility. Within the frameworks surveyed, composition and assembly stay in the host process, and this work moves them onto a bus shared by peer nodes.

3 Preliminaries The notation fixes a context Γ, an effect context 𝜕Γ made of the state 𝛾 and the accumulated inverse composite 𝜑 , the two transformations track and recover, the transformation monoid 𝔐(𝑓 ), observational equivalence ≃, the macrostate projection Π, and compositions reading from right to left. Theorem numbers follow the calculus, and notations introduced in Section 4 are defined at their first occurrence. Definition 3.1 (Component). A component is an effect function on the context, a map 𝑓 that takes a state 𝛾 to a pair of a new state

Research Paper Track

𝛿 and an inverse map 𝑔 , where the inverse returns the state it was chosen at, 𝑔(𝛿) = 𝛾 , and is unconstrained everywhere else. A single 𝑔 with

𝑔 ∘ 𝑓 = id (1) meets the constraint at every state at once and induces an element of the witnessed form, and the calculus proves the induction a homomorphism. Definition 3.2 (Assembly and removal). Assembly and removal are the two transformations track and recover, where track applies an effect and extends a running composite of inverses, and recover applies that composite to the current state and resets it, so that removal reverses every applied assembly in the reverse order of application. What each tracking step preserves is the result of recovery itself, from whatever state it is taken. Definition 3.3 (Independence). Two effect functions are independent when every transformation of one commutes with every transformation of the other, and neither one’s transformations disturb the inverse the other yields. The global theorems of the calculus assume pairwise independence, and coeffect operations on disjoint keys commute unconditionally. Definition 3.4 (Soundness invariant). The soundness invariant states that for every effect pair with 𝑔(𝑓 (𝛾 )) = 𝛾 , recovering after tracking returns what recovering before tracking would have returned, that is, the value 𝐼 (𝛾 , 𝜑) = 𝜑(𝛾 ) (2) is unchanged along every witnessed track step, and recover reads it out. The invariant is a property of the state space alone, its definition refers to the context and to composition of maps and to no process, no memory, and no closure. Definition 3.5 (Observational equivalence and macrostate). Observational equivalence ≃ relates two states when no observer of the context can distinguish them, and the macrostate of 𝛾 is its equivalence class under the projection Π.

AAMAS 2027, 3–7 May 2027, Hanoi, Vietnam

4 Sufficient Conditions 4.1 From One Process to an Assignment The formal model of the calculus shares one context Γ∞ , the recursive context type of the calculus, among all plugins, all records of assembly and removal, and all sessions it hosts. The soundness invariant of Definition 4 carries no carrier, it is a property of the state space alone. The records of assembly and removal lack this freedom, they reside in the shared context, and the shared context resides in the process that hosts it. The calculus states no theorem for more than one process, and its sole treatment of the process boundary is an application note, in which the service broker spans processes and calls obey an asynchronous contract. The implementation of the calculus hosts the shared context in a single process. This paper therefore relaxes the co-residence restriction, the confinement of components and records to one process, to an arbitrary assignment of components and records to processes, and the soundness invariant imposes no constraint on the assignment. Under an assignment, an abstract trace is a sequence of assembly and removal steps in the state space, and an implemented trace is the sequence of steps the processes actually perform. An assignment is faithful when for every abstract trace 𝜏 there is an implemented trace 𝜏 ′ such that the two agree pointwise under Π,

Π(𝜏 ′ ) = Π(𝜏 ).

4.2

(3)

Two Modeling Facts

The first modeling fact is that a forward pass of the language model is a stateless pure map, all cross-step state already resides outside the model, and the input can be synthesized anywhere. The second modeling fact is the minimal model 𝑦 = 𝑓 (𝑥), input synthesis and output parsing are operations outside 𝑓 , and a multi-turn session is nested passes of 𝑓 with synthesis and parsing as the outer routing. Together the two facts make a session a sequence of stateless maps over an external sector, and co-residence a choice.

4.3

Four Lemmas

The physical equality of recovery is an idealization, because the physical state cannot be recovered as it stood, and every recovery equality holds up to ≃.

Lemma 4.1 (ORchestRation exteRnality). If the model is a stateless pure map and synthesis and parsing are outside it, then all cross-step state resides in a shared sector 𝑆 , the store the runtime reads and writes, outside any model call, the runtime’s entire role is the two operations of input synthesis 𝜔 and output settlement 𝜌 , and the model becomes an ordinary dispatchable node.

Definition 3.6 (Registry). A registry 𝐹𝛾 carries each fiber under its name and is well formed when parent pointers form one tree rooted at a common root, the provides sets of distinct fibers are disjoint, and a committed view resolves a demand key to at most one installed provider.

Cross-step state cannot live inside a stateless map, and synthesis and parsing are defined as external operations, so the shared sector is the only remaining residence, and the sector being readable from anywhere, the input 𝑥 = 𝜔(𝑆) is the system state made inputtable and can be synthesized at any process.

Preservation of this form is a theorem of the calculus, every rule step carries a well-formed registry to a well-formed one.

Lemma 4.2 (CaRRieR substitution). Let 𝒟 be the inverse data of a history with anchors 𝑎𝑖 and inverses 𝑔𝑖 . A persistent store 𝒞 with a readout map 𝜌 is a faithful carrier when 𝜌(𝑎𝑖 ) ≃ 𝑔𝑖 holds at every anchor, and the accumulator rebuilt from the carrier by composition in application order is ≃-equal to the original, so recovery through the carrier equals in-place recovery under Π.

Definition 3.7 (The outside). An operation is outside the boundary when the system can neither exclusively modify nor recover its state, an outside operation acts as the identity on the context and is neither tracked nor recovered, and emission, the crossing form, has withholding and compensation as its only routes. Compensation holds at a coarser equivalence.

The inverse data form a monoid, a composite of maps that respect ≃ respects ≃, pointwise equality of readouts composes to

Research Paper Track

AAMAS 2027, 3–7 May 2027, Hanoi, Vietnam

equality along the chain, and recover merely evaluates the invariant. Reversibility leaves a record, a persistent carrier is the physical lower bound of the reversible, and process memory under a deployment that tolerates process death satisfies the premise for no process. The most general persistent carrier of a monoid element is the free monoid on its generators, an append-only transcript, and a new process that imports the transcript rebuilds the external accumulator and composes it with what the failed process had kept.

Table 2: The four lemmas against the parts of the construction that satisfy them.

Lemma 4.3 (RecoveRy localization). Let the effect functions of components 𝑐1 through 𝑐𝑀 be pairwise independent in the sense of Definition 3, and let an arbitrary partition place them into 𝑁 processes. The inverse data of a component then need reside only in its own process, global recovery is any global interleaving of the perprocess recoveries, and no ordering constraint and no shared state exists between processes for the sake of recovery.

3, recovery localization

Any interleaving of the local last-in-first-out sequences is a permutation of all the inverses, recovery is invariant under permutation of the applied inverses, so the endpoint is the same whichever interleaving runs. The shared mutable state of this system is entry tables whose operations are appends and deletions, which fall inside the domain the commutative keys satisfy, and the discharge mechanism of the calculus is the basis. Shared databases and quota resources pass through single-writer tools or stay outside the boundary. Lemma 4.4 (ExteRnal Resolution). The operating requirements of spatial composability are the real-time resolution of keys to providers, a single writer per key, and supply before demand with withdrawal after consumption, and their content is entirely an assignment of keys to providers, that is, a routing table. The routing table is the representative case of a commutative key in the calculus, registration is a revertible effect, so the table resides in the commutative part of the state space and a copy maintained by broadcast of registration events is observationally equivalent to an in-memory registry.

4.4

The Theorem

TheoRem 4.5. An implementation over 𝑁 processes is a faithful implementation of the calculus and the two modeling facts when every effect that must be reversible writes its anchor to a persistent transcript at the step of occurrence, and every key admits one writer, enforced at registration. Under the two conditions, Lemma 1 places the state in the shared sector and Lemma 2 makes the transcript a faithful carrier. Lemma 3 confines each component’s recovery data to its own process and Lemma 4 moves resolution to the routing table, and an induction over the abstract trace yields an implemented trace agreeing with it pointwise under Π. PRoof sKetch. The base case holds, the empty abstract trace is implemented by the empty trace. Each assembly step uses Lemma 1 to place the state in the shared sector and Lemma 2 to make the transcript prefix the anchor record, and the pointwise agreement under Π holds after the settlement is recorded. Each removal step uses Lemma 3 to confine recovery to the component and Lemma

Lemma

Satisfied by

1, orchestration externality

the model as an ordinary dispatchable node on the bus the append-only transcript and cold switching capabilities as independent processes, recovery data per process the router holding only the routing table, registration as a revertible effect

2, carrier substitution

4, external resolution

4 to move resolution to the routing table, and the pointwise agreement under Π follows. The full induction appears in the appendix. □ Under the idealized model, the theorem admits a distributed implementation. The practical construction is subject to three constraints, E1 every response is paired with its own call, E2 each name carries exactly one registration and a conflicting claim receives an explicit refusal, and E3 every observer receives the same sequence of supply-change notifications. The single-registration constraint is the single-writer clause of the theorem enforced at registration, and the common order of notifications is the supply order of Definition 6 carried by the broadcast. A deployment as a set of peer processes is admissible once the bus time scale separates from the model time scale, a millisecond hop against a first token a hundred times slower, the topology stationary at the step scale of the model. Table 2 lists the four lemmas against the parts of the construction that satisfy them.

5 The Logos Construction This construction moves composition and assembly out of the host process. A bus takes the place of the host. The routing table belongs to the bus. The transcript and the event stream belong to no process. A plugin is a process. A message follows the full path, the harness synthesizes input from the transcript, the model answers, the router forwards the tool call, the result settles into the transcript, and the broadcast carries the change to every node. Figure 1 shows the construction.

5.1

The Bus

The router is a single Go process that registers nodes and forwards messages by recipient. Its three duties are registration, forwarding, and broadcast, a node registers under an id with a role and a list of provided capabilities, a call is forwarded to the node whose capability matches, and an event is delivered to every registered node. The router holds only its routing table, it schedules nothing and it reads no payload. A message names its recipient, an id for a direct delivery, the wildcard for a broadcast, and a missing recipient returns an explicit error to the sender. The wire protocol is NDJSON over TCP, one object per line, frames up to 64 MB, malformed lines skipped,

Research Paper Track

AAMAS 2027, 3–7 May 2027, Hanoi, Vietnam

Algorithm 1 Harness loop with recovery Require: session id, transcript 1: import the transcript, rebuild the projection 2: loop 3: synthesize input from the projection 4: call the model, stream the answer into the transcript 5: if the model asks for a tool then 6: route the call, append the result to the transcript 7: end if 8: settle outputs, broadcast the change 9: {on process death, resume from the first line} 10: end loop

Figure 1: The Logos construction, peer processes on a bus, the router holding only its routing table, harnesses and tools as nodes, and the append-only transcript outside any process. and lossy streams are separated from control messages, which are paired and never dropped. Each connection holds a bounded outbound queue of 1024 entries with its own writer coroutine, a write timeout of five seconds disconnects the peer, a full queue drops the oldest entry of a lossy stream and counts the drop in a notice, and a full queue of control messages disconnects the peer. Delivery is layered, control messages arrive at least once with idempotent pairing by global call ids, and a lossy stream loses at most a prefix, the surviving sequence stays contiguous. A disconnected node re-registers, and the replay fills the gap. Every registration and every refusal returns a receipt to its sender, and a refused duplicate name carries an explicit denial. The bus imposes no language, a tool is any process that implements the protocol, and Go, Python, and Node.js processes run as peers on one bus in this system. The bus meets the three constraints by construction, pairing by global call ids, single registration by explicit refusal, and one order by serialized broadcast.

5.2

The Routing Table

The routing table maps a name to a connection, together with the role and the provided capabilities. Any node can read the whole table at any time, registered or not. Registration adds a row, departure deletes it, and the online and offline broadcasts carry the change to every node. One name admits one row, and a conflicting claim receives an explicit refusal. Registration is a revertible effect, and a copy maintained by broadcast of registration events is observationally equivalent to the in-memory table, following Lemma 4.

5.3

The Transcript

The transcript is an append-only JSONL file owned by no process, the single source of truth, and every step of every session is written to it as it happens. An entry records the round, the input, the tool uses with their results, and the streamed text. Messages shown to the model are a projection over the transcript, long tool results are pruned in the projection while the full text remains in the file, and nothing is removed from the file itself. The append-only form is the

free monoid on the generators of the inverse data, the mathematical carrier of Lemma 2. The replay of a transcript is checked against four invariants, I1 entries follow a well-formed order, I2 identifiers are monotone, I3 every tool use has exactly one result, and I4 the rebuilt projection equals the messages the session showed. The settlement order is durable before visible, an effect is appended to the transcript before it is announced on the bus.

5.4

The Event Stream

An observer node records every broadcast into an append-only file, the event stream. The stream covers system behavior, the transcript covers the session, and the two stay separate. The same replay checks apply to both.

5.5

Nodes

A node is any process that conforms to the protocol, and anything the rules admit mounts as a peer. A harness runs the loop of input synthesis, model calls, and output settlement over one session, and a tool provides a capability. A node registers with one of three roles, harness, tool, or observer, and the observer receives every broadcast and announces nothing. Every process holds the same handle, and the roles differ only in the register call. Harnesses and tools count equally as residents, and the router exits when no resident remains. Algorithm 1 gives the loop.

5.6

Assembly, Removal, and Recovery

A capability is a process, tools mount at their own endpoints with the router unchanged. Mounting with a missing provider leaves the component in waiting, its calls answered by an explicit refusal naming the missing capability, and a later online broadcast activates it without code change on any side. A provider going offline triggers re-resolution, a replacement provider of the same capability rebinds the dependents, and a provider announcing departure waits for its confirmed dependents to leave before it withdraws. The discipline is a soft layer over the late binding of the bus, a component that follows none of the three stages still runs, its calls answered with an explicit error at the layer below. The order follows Definition 6, supply precedes consumption and withdrawal follows it. After any process dies, a new process of the same id imports the transcript, rebuilds the projection, and continues the session. Recovery has no rollback and no fork, the rebuilt view equals the view the failed process held, and the steps already recorded are

Research Paper Track

never repeated. The rebuilt accumulator composes with whatever the failed process had kept, following Lemma 2, and no other process participates, following Lemma 3. An outward effect, payment for example, stays outside the boundary, untracked and unrecovered, with withholding and compensation as its only routes.

5.7

Deployment Boundary

Every deployment of this paper runs within trusted networks, on one machine over the loopback bus and on private grids, and admission to the bus is registration. Trust is placed at mounting, a tool is admitted by a person who has reviewed its code and started its process. The transcript remains plaintext, and its single-source form is a design choice. Snapshot and compaction are engineering items that archive prefixes and leave replay semantics unchanged.

6 Experiments 6.1 Testbed All measurements run on one machine, an AMD Ryzen 7 7435H with 16 GB of memory under Windows 11, the router and every node as separate processes over the loopback bus, the router in Go 1.26, harnesses and tools in Python 3.13 and Node.js 24. The models in these measurements are DeepSeek V4 Flash, DeepSeek V4 Pro, GLM-5.2, GLM-5.3, Claude Opus 5, Claude Opus 4.6, GPTImage-2, and GPT-5.4, the end-to-end and multi-agent runs use DeepSeek V4 Flash, the crash-point runs use GLM-5.2, and GPTImage-2 is the model behind the imagegen tool. Faults arrive as kills of live processes from outside the system. Every assertion is checked against two independent on-disk sources, the transcript and the event stream, and every scenario carries a replay command. Table 3 lists the scenarios. The comparison group composes the same session code from the reference implementation of the calculus, same faults, same injections, same criteria, and what the comparison varies is the form of residence. The reference configuration composes the session code natively with zero source changes, both configurations receive identical injections through the same functions and thresholds, and the no-fault baseline differs by 0.8 percent, so the measured damage belongs to the fault.

6.2

Scale Separation

A bus hop costs a median of 0.215 ms over 10000 calls, with a 99th percentile of 0.377 ms, a 99.9th percentile of 0.623 ms, and a maximum of 3.045 ms. The in-process baseline is a median of 0.005 ms, so the bus costs 43 times a local call. The model side costs a median first token of 177 ms over three calls and a median full inference of 1896.8 ms, so one hop is 1/823 of the first token and 1/8822 of the full inference. Three orders of magnitude separate the two scales, and the topology is stationary at the step scale of the model. Concurrent loads of 50, 100, and 200 callers run three rounds each with zero losses, and an audit of 3500 calls from 200 concurrent callers pairs every call with its answer, with no loss, no duplication, and no misattribution. A compute-bound pair of tools, each saturating one core, finishes in 2000.8 ms on two cores against 4001.3 ms serialized in one host, the two-to-one gap being the host’s single core.

AAMAS 2027, 3–7 May 2027, Hanoi, Vietnam

Table 3: The measurement scenarios and their headlines. Scenario

Model

Headline

Bus hop latency

GLM-5.3

Model-side latency

DeepSeek V4 Flash Claude Opus 4.6

median 0.215 ms over 10,000 calls first token 177 ms, full inference 1896.8 ms 20 and 10 trials, all sessions alive pure-function check 100 of 100 12 of 12 sessions

Router and tool kill Cold-switch mechanism End-to-end resumption Crash points

DeepSeek Flash GLM-5.2

Plugin assembly

DeepSeek V4 Pro

Multi-agent faults

DeepSeek Flash GLM-5.3

Contention and adoption Conformance audit

6.3

GPT-5.4 V4

V4

Claude Opus 5

80 of 80 sessions at four kill points removal 10 of 10, modification 5 of 5 three harnesses, two injected faults 4.00 s serialization, first call 8.4 s 3,500 paired calls, violations zero

Router Kill

Killing the router process in twenty trials leaves every node alive and every session running, the nodes reconnect through supervision, and restoration takes a median of 858 ms, every trial between 857 ms and 860 ms. The restoration window is set by the supervision polling granularity, the supervision loop polls, detects, and relaunches, and the window follows the polling loop alone. The death of the router narrows the failure domain from every session to the routing-change window, nodes keep their sessions running through direct connections. Killing a tool process in ten trials returns errors to its callers in 0.321 ms, the provider remounts in 100.5 ms on the production grid, and the transcript replays under I1 through I4 without a bad line. For comparison, killing the whole host of the single-process configuration is detected in 149.5 ms by the external watchdog and the full stack restarts in 397.9 ms with a total outage of 547.1 ms, while the same fault here ends with the node remounted in 41.3 ms in thirty trials on the comparison grid and the other nodes unaffected.

6.4

End-to-End Resumption

Twelve sessions run under six process kills, all twelve deliver under the same criteria, no previously executed action is repeated, and the rounds after each kill are 3, 4, 2, 3, 2, and 4. A restart costs 1.36 s, following the path of Theorem 1, the transcript prefix as the anchor record and the rebuilt accumulator composed onto it. The white-box replay of the event streams passes I1 through I4 with monotonically matching identifiers, and an extended run of thirty resumptions succeeds in 30 of 30 trials.

Research Paper Track

AAMAS 2027, 3–7 May 2027, Hanoi, Vietnam

turns with every step on the transcript, and the three rounds deliver all results correct. Six results are recomputed and the faulting session takes 135 seconds against the 5 seconds of the untouched sessions, the unavoidable cost of the injected fault. Two harnesses claim the tool simultaneously, the calls serialize through 4.00 s, each answer returns to its own caller, and no false timeout occurs. The three sessions recover each from its own shard of the transcript with no coordination, Lemma 3 partitioned per session.

6.7 Figure 2: The timeline of the concurrent sessions, three harnesses share one tool, the router and the tool provider killed together, the fault detected through the broadcast, the tool remounting, and the three rounds completing.

Eighty further sessions extend the coverage to four kill points of the tool-call cycle, during execution, after return but before persistence, after persistence but before announcement, and after announcement. All eighty resume and complete with no repeated effect, and the work redone after recovery equals exactly the work the transcript had not yet recorded, four rounds at the first two points, three at the third, two at the fourth.

6.5

Assembly, Adoption, and Arbitration

Removal with a tracked inverse succeeds in 10 of 10 trials with the external state remounted, in-place modification of a mounted tool succeeds in 5 of 5, isolation between sessions sharing the bus holds in 10 of 10 with a median hop of 0.243 ms, and fifteen rounds of churn among providers leave the table equal to the set of living providers in 15 of 15 trials. A tool coming online during a task is adopted autonomously, the first call arrives 8.4 s after the registryupdate broadcast with no prompt naming the tool, and three such adoptions all succeed, an extended run at 10 of 10. One registration wins among one hundred simultaneous claims of the same name with ninety-nine explicit denials, each denial reaching its claimant, and two observers record identical supplychange sequences across thirty rounds of churn among fifty providers, the event stream alone reconstructing the final table. A duplicate name never enters the table, and an online tool reaches its consumers through the broadcast alone.

6.6

Concurrent Sessions

Three harnesses share one tool under two injected faults. The provider of the shared tool is killed alongside the router, the fault is detected in 2.8 ms through the broadcast, the tool remounts in 1 s and the model adopts it autonomously, and the system restores service. Figure 2 shows the timeline of the two faults and the recovery. The window costs six interim results, the three rounds complete in 9, 4, and 3 turns, and the two faulting sessions deliver with two errors each, both caught and repaired at the time. The calls inside the window reach the dead provider and return explicit errors, the loud failure of the injection, the model retries and corrects in later

Single-Process Comparison

Both configurations run the same session code under the same faults. The single-process configuration composes it from the reference implementation of the calculus [1], version v0.1.0-rc.5 with 250 file fingerprints recorded, and faults arrive as process-tree kills from outside either configuration, and the criteria are the same, an interruption being a session’s largest gap between consecutive outputs exceeding one and a half times its period. What the comparison varies is the form of residence, one host process versus a set of peer processes. Restoration after provider withdrawal in the single-process configuration is serial in the number of dependents. Each dependent’s setup re-runs on the shared event loop, one after another, so with 50 ms of loading work per dependent the restoration takes 250.9 ms at five dependents, 501.5 ms at ten, and 1003.0 ms at twenty, and during the whole restoration an unrelated session in the same host cannot run, frozen for 987.2 ms at twenty dependents. The loading work is controlled injection, and the measurement reads the slope of the per-dependent restoration cost across the three dependent counts. The share of this time that the swap mechanism itself accounts for is the empty-closure floor, 0.263 ms to withdraw and 0.567 ms to restore, which is 0.2 percent of the restoration at five dependents and 0.06 percent at twenty. The single-process advantage in swapping cost exists only when the components being swapped do no work, and under real loading it vanishes into the serial re-execution it must perform. The peer-process construction pays one process start, 126.3 ms measured at the twenty-dependent point, and an unrelated session in its own process runs throughout, with zero freezing. A component whose remote resource goes offline terminates its host. The unhandled rejection from the connection attempt propagates past the plugin boundary and ends the whole process in all five trials, and repair requires redeploying the resource and coldrestarting the entire stack, 1105 ms before the session runs again. The failing node in the peer-process construction returns an explicit error to its caller and keeps running in all five trials, and repair is the resource’s return, the next round resuming in 107.8 ms, since the node never died and there was nothing to restart. The host’s death reaches every session it hosts, so the number of interrupted sessions is the number of co-resident sessions, a structural consequence of hosting sessions in one process rather than a measured trend. The five-session composition shows this law in both directions. A single hosting process turns one session’s fault into the interruption of all five sessions it hosts, in ten trials out of ten. The four sessions independent of the fault stopped with the host, the pipeline restarted at step one, discarding completed steps

Research Paper Track

AAMAS 2027, 3–7 May 2027, Hanoi, Vietnam

Table 4: The single-process reference configuration and the peer-process construction under the same faults. Fault

Single-process ence

Host killed

refer- Peer-process construction

149.5 ms detected, 547.1 ms total outage, every co-resident session interrupted Provider with- closure unload 0.263 ms, drawn restore 0.567 ms Provider restarted Cascade cost Remote offline Co-resident fault No fault

remount 41.3 ms in 30 of 30 trials, other nodes unaffected

loud error 1.02 ms, remount 80.28 ms in 10 trials 0.518 ms, dependents 10 remount 94.5 ms, callers of 10 reloaded 10 of 10 untouched 50 ms per dependent, one process start 126.3 987 ms freeze ms, zero freezing host crash 5 of 5, repair node alive 5 of 5, repair 1105 ms 107.8 ms host dies 10 of 10, 4 of 4 faulty node only 10 of innocent sessions inter- 10, 0 of 4 interrupted rupted makespan 24516 ms makespan 24722 ms, 0.8 percent gap

and recorded progress. Peer processes turn the same fault into one node’s replacement, in ten trials out of ten. Those four sessions delivered without a single gap, the pipeline completed monotonically, and the archive progress strictly advanced. Table 4 lists the two configurations side by side.

6.8

Verification

Fifteen unit tests check the replay invariants, and a past incident is detected in the same replay, two writers, five orphaned entries, and two inversions, caught by I1 through I4 in the event stream. Approval runs in two layers, dry runs touching nothing outside and full runs leaving a record, and the endpoint contract passes six scenarios with nine assertions. Three checks link the layers together, the pure-function check passes 100 of 100 and establishes the premise of Lemma 2, the cold-switch check passes 12 of 12 and establishes Corollary 1, and the contract check establishes the behavioral face of external resolution. I1 through I4 form an audit layer over every measurement of this section, and a replay either holds at every entry or names the entry that fails.

7

Conclusion

This paper established sufficient conditions under which the reversibility guarantee of the spatiotemporal-composability calculus survives the process boundary. The premises of the four lemmas are the hypotheses the calculus already states and the statelessness of language-model inference. On these conditions it constructed Logos, where a plugin is a process, the router holds only a routing table, the only shared state is an append-only transcript, and the construction satisfies the lemma conditions and the three conditions of the distributed carrier.

Measurements on one machine show twelve sessions resumed through six kills and eighty further sessions through kills at the four boundaries of the tool-call cycle with no repeated effect, nodes reconnect and routing resumes after router loss, and a same-fault comparison in which one fault interrupts every co-resident session while under the peer-process construction one fault ends at one node. The commutation discipline holds as an architectural fact, the shared mutable state of this system being entry tables, the broadcast order carries the supply order, the failure behavior of the channel is covered by engineering evidence, the router is a single process whose death narrows the failure domain to the routingchange window, and the append-only transcript replays the full session. Future work strengthens each item into its formal counterpart, a per-key verification of the discipline, a proof of coverage for the order, a formal semantics of loss, partition, and reconnection, and extends the construction across machines and to larger provider sets.

References [1] DeepSeek-AI. 2026. DeepSeek Harness: Everything is a Plugin. https://github. com/deepseek-ai/deepseek-harness. Reference implementation of the calculus, version v0.1.0-rc.5, 250 file fingerprints recorded. [2] Xinyi Hou, Yanjie Zhao, Shenao Wang, and Haoyu Wang. 2026. Model Context Protocol (MCP): Landscape, Security Threats, and Future Research Directions. ACM (2026). doi:10.1145/3796519 [3] LangChain Inc. 2024. LangGraph: Building Stateful, Multi-Actor Applications with LLMs. https://github.com/langchain-ai/langgraph. In-process graph orchestration library. [4] Yang Li, Siqi Ping, Xiyu Chen, Xiaojian Qi, et al. 2025. AgentGit: A Version Control Framework for Reliable and Scalable LLM-Powered Multi-Agent Systems. arXiv preprint arXiv:2511.00628 (2025). [5] Qin Liu. 2026. 𝜆𝐴 : A Typed Lambda Calculus for LLM Agent Composition. arXiv preprint arXiv:2604.11767 (2026). [6] Morgan Quigley, Brian Gerkey, Ken Conley, Josh Faust, Tully Foote, Jeremy Leibs, Eric Berger, Rob Wheeler, and Andrew Y. Ng. 2009. ROS: an open-source Robot Operating System. In ICRA Workshop on Open Source Software. [7] Yifan Shi, Wei Zhang, and Tianyi Cui. 2026. A Programming Paradigm for Spatiotemporal Composability. arXiv preprint arXiv:2608.25512. Submitted August 26, 2026. https://doi.org/10.48550/arXiv.2608.25512. [8] Temporal Technologies Inc. 2025. Temporal Workflow Execution Platform. https: //docs.temporal.io. Durable execution engine; workflows defined in code, recovery via event replay. [9] Qingyun Wu, Gagan Bansal, Jieyu Zhang, Yiran Wu, Berc Li, Erkang Zhu, Li Jiang, Xiaoyun Zhang, Shaokun Zhang, Jiale Liu, et al. 2024. AutoGen: Enabling NextGen LLM Applications via Multi-Agent Conversation. In First Conference on Language Modeling (COLM). arXiv:2308.08155.

A Proofs A.1 Setup Fix an assignment of components and records to 𝑁 processes and the two conditions of Theorem 1, every effect that must be reversible writes its anchor to a persistent transcript at the step of occurrence, and every key admits one writer, enforced at registration. An abstract trace is a sequence of assembly and removal steps in the state space. An implemented trace is the sequence of steps the processes actually perform. The theorem constructs, for every abstract trace, an implemented trace that agrees with it pointwise under the macrostate projection Π.

A.2

Proof of Lemma 1

The proof rests on the two modeling facts. By the first fact, a forward pass of the language model is a stateless pure map, so crossstep state cannot live inside the model. By the second fact, input

Research Paper Track

synthesis and output parsing are defined as operations outside the model. The shared sector is therefore the only remaining residence for cross-step state. Co-residence with the model then carries no state that must stay in the model’s process, and the absence of this necessity is the contrapositive, co-residence would be necessary only if the state lived inside the model, which the first fact denies, or if synthesis and parsing had to run where the model runs, which the second fact denies by defining them as external operations. Since the sector is readable from anywhere, the input 𝑥 = 𝜔(𝑆) is the system state made inputtable and can be synthesized at any process, and the model becomes an ordinary dispatchable node.

A.3

Proof of Lemma 2

The inverse data form a monoid, the composite of two maps that respect ≃ respects ≃, pointwise equality of readouts composes to equality along the chain, and recover merely evaluates the invariant. Each of these steps is a fact of the calculus. Definition 37 requires inverses to respect ≃, Lemma 38 supplies the machine that composites of maps respecting ≃ respect ≃, the premise 𝜌(𝑎𝑖 ) ≃ 𝑔𝑖 at every anchor then composes pointwise along the chain of anchors, and the readout of the accumulator equals the invariant read. Recovery through the carrier therefore equals in-place recovery under Π. Three corollaries follow. The first is the necessity of a record. Reversibility leaves a record, a persistent carrier is the physical lower bound of the reversible, and this is the commonsense form of the Landauer principle, stated without a formal citation. Process memory under a deployment that tolerates process death satisfies the premise for no process, since the process can die, so process memory fails the carrier condition in any fault-tolerant deployment. The second corollary is the derivation of the append-only form. The algebra of the inverse data is a monoid, and the most general persistent carrier of a monoid element is the free monoid on its generators, an append-only transcript. The mathematical derivation reaches exactly the append-only replayable form. The plaintext form and the single-source form are design choices, not derivations. The third corollary is cold switching. A new process imports the transcript, rebuilds the external accumulator, and composes it with what the failed process had kept, the full accumulator being the composite of the external and the in-process parts. The departure of the original process leaves the soundness invariant untouched, and under this lemma a process is a disposable auxiliary carrier.

A.4

Proof of Lemma 3

Any interleaving of the local last-in-first-out sequences is a permutation of all the inverses. Corollary 21 of the calculus asserts that recovery is invariant under permutation of the applied inverses, so the endpoint is the same whichever interleaving runs. The local storage claim and the no-coordination claim follow from the arbitrariness of the permutation. The local storage claim additionally rests on the confinement of Definition 48 and on the disjointness of supply of Definition 58. The shared mutable state of this system is entry tables whose operations are appends and deletions, which fall inside the domain the commutative keys satisfy, and the discharge mechanism of the calculus is the basis. Shared databases

AAMAS 2027, 3–7 May 2027, Hanoi, Vietnam

and quota resources pass through single-writer tools or stay outside the boundary.

A.5

Proof of Lemma 4

The operating requirements of spatial composability are each a fact of the calculus, the real-time resolution of keys to providers rests on Definitions 45 and 46, the single writer per key on Definition 58, and supply before demand with withdrawal after consumption on Theorem 63. Their content is entirely an assignment of keys to providers, a routing table. The routing table is the representative case of a commutative key in the calculus, the registration of a route or of an event listener being the representative case in the original text, and registration is a revertible effect, each provider registering with the broker through a revertible effect. The table therefore resides in the commutative part of the state space, and a copy maintained by broadcast of registration events is observationally equivalent to an in-memory registry. The correspondence between the calculus constructs and the Logos construction is the following. Table 5: The calculus constructs against the parts of the Logos construction that realize them. Calculus construct

Logos realization

𝐹𝛾 and the per-key provider map

the router registry, register with provides and query the routing table notify𝑑 of Definition 26 the node online and offline broadcasts driving the tool view the committed view the routing in use, the current resolution the order of Theorem 63 the broadcast order plus the serialized registration the single writer of Defini- the registration conflict refusal, tion 58 measured

A.6

The Construction Checklist

The Logos construction satisfies the four lemmas through the following parts. C1 through C4 are given by the lemma conditions, C5 by Lemma 1 together with Lemma 2, C6 is the direct management of the boundary of Definition 7, and C7 makes the projection computable.

A.7

The Three Engineering Constraints

The cross-process execution requires three engineering constraints beyond the lemma conditions. E1 pairs every response with its own call, E2 carries exactly one registration per name with an explicit refusal for a conflicting claim, and E3 delivers the same sequence of supply-change notifications to every observer. The construction meets E1 through the single NDJSON protocol and the bounded queues, E2 through the registration conflict refusal, and E3 through the broadcast order plus the serialized registration. The

Research Paper Track

AAMAS 2027, 3–7 May 2027, Hanoi, Vietnam

Table 6: The construction parts against the lemma conditions they satisfy. Construction part

Satisfied condition

C1, a capability is an independent process C2, the router routes and registers only, holding no business state C3, the transcript is append-only and plaintext, the single source of truth C4, cold switching resumes the same id C5, the model is an ordinary dispatchable bus node C6, outward effects stay outside the boundary C7, every event is broadcast and replayable

recovery localization, the component unbound from a host external resolution and carrier substitution, the registry rebuilt by reregistration the free monoid carrier, the replayable form a derivation and the plaintext form a design choice the composition of the rebuilt accumulator with what the failed process kept orchestration externality and carrier substitution Definition 7, withholding and compensation as the only routes the computable projection, the macrostate reconstructable from the event stream

three constraints are engineering realizations, and their formalization is future work, the failure semantics of the asynchronous contract, loss, partition, and reconnection, being covered by engineering evidence at present.

A.8

The Induction

A.8.1 Base Case. The empty abstract trace is implemented by the empty trace. Both sides start at the same macrostate, and the agreement holds vacuously. A.8.2 Assembly Step. Let the abstract trace end in an assembly step. By Lemma 1 the cross-step state resides in the shared sector outside any model call, so the assembly step does not require the state to live inside the executing process. By Lemma 2 the transcript is a faithful carrier, and the step writes its anchor to the transcript at the step of occurrence, by the first condition of the theorem, the settlement order being durable before visible, the anchor lands in the transcript before the step is announced on the bus. The induction hypothesis gives an implemented trace agreeing with the abstract prefix under Π up to this step. The constraint E1 pairs the response of the step with its call, so the implemented trace contains exactly one step corresponding to the abstract assembly step, and the settlement recorded at the anchor keeps the pointwise agreement under Π after the step. The macrostate after the step is determined by the anchor alone, so any process that reads the transcript prefix reaches the same macrostate. A.8.3 Removal Step. Let the abstract trace end in a removal step. By Lemma 3 the inverse data of the component reside in its own process, and the local last-in-first-out recovery is invariant under

any interleaving of per-process recoveries, so the removal step needs no ordering constraint and no shared state with any other process. By Lemma 4 the resolution of the removed component moves to the routing table, and the routing table is maintained by registration broadcasts, a copy being observationally equivalent to an in-memory registry. The constraints E2 and E3 guarantee that the registration state and the supply-change order seen by every observer agree with the abstract resolution step. The pointwise agreement under Π follows from Lemma 3 for the recovered component and from Lemma 4 for the unchanged resolution state. A.8.4 Completion. Induction over the abstract trace assembles the two step cases, and the implemented trace agrees with the abstract trace pointwise under Π at every step. The implementation is faithful, and the theorem follows. The admission of the deployment as a set of peer processes requires the bus time scale to separate from the model time scale, a millisecond hop against a first token a hundred times slower, and the topology stationary at the step scale of the model, under which the asynchronous contract of the application note holds throughout the induction.

Related documents

• Logos: An Agent Harness on a Cross-Process Bus#974585
• Um modelo de análise de viabilidade para desenvolvimento de componentes#946342
• The Use of Agents by Digital Financial Services Providers : Technical Note#8560
• Desarrollo de un modelo de presentación y costeo del ciclo de vida de buses eléctricos para la industria de transporte masivo de pasajeros#403344
• Hubungan Kualitas Tidur Terhadap Kadar Glukosa Darah Sewaktu dan Kadar Trigliserida pada Sopir Bus#670789