LogAction: Log-Centric Computation

• LogAction is a log-centric computation model that records actions as immutable, append-only events, serving as the primary source of truth for state and auditability.
• It employs event-sourced and shared-log architectures to enable deterministic replay, efficient forking, and consistent recovery in distributed, multi-agent environments.
• The approach supports auditable behavior controls and integrates with responsible ML logging and anomaly detection, offering practical insights for system reliability and workflow abstraction.

to=arxiv.search 】!【json {"query":"LogAction OR LogAct append-only event log agent shared log auditable forkable activegraph", "max_results": 10, "sort_by": "submittedDate", "sort_order": "descending"} to=arxiv.search 天天中彩票充值მა еиԥшjson {"query":"(Nakajima, 21 May 2026) OR (Balakrishnan et al., 9 Apr 2026) OR (Duan et al., 29 Sep 2025) OR (Foalem et al., 25 Aug 2025)", "max_results": 10, "sort_by": "relevance", "sort_order": "descending"} LogAction denotes a log-centric conception of computation in which actions, decisions, or agentic intentions are recorded as first-class log entries and the resulting log is used not merely for observability but as an operational substrate. In ActiveGraph, “LogAction” is not a metaphor: the append-only event log is the source of truth, the working graph is a deterministic projection of that log, and behaviors act only by appending new events (Nakajima, 21 May 2026). In LogAct, each agent is a deconstructed state machine playing a shared log, where agentic actions are visible in the shared log before they are executed, can be stopped prior to execution by pluggable, decoupled voters, and can be recovered consistently in the case of agent or environment failure (Balakrishnan et al., 9 Apr 2026). Related work applies the same orientation to responsible ML logging, categorical action databases, interaction-history workflows, and log analysis, suggesting a broader family of systems in which the log is treated as an executable, auditable, or inferential object rather than exhaust (Foalem et al., 25 Aug 2025).

1. Terminological scope and neighboring formulations

The term appears in multiple, closely related senses. In ActiveGraph it names a runtime principle: “the log really is the agent.” In responsible ML, it denotes a structured LogAction per decision or batch that links model version, pipeline version, fairness metrics, privacy budget, explainability artifacts, and user-facing outcomes. In cognitive-logs, the central claim is that “action is the primary key,” with actions represented as first-class database entities connected to participants and causes. In interaction-log systems, the unit is a recorded visualization state or atomic UI event that can later be abstracted into a reusable workflow or high-level activity (Nakajima, 21 May 2026).

Formulation	Core logged unit	Stated role
ActiveGraph	Append-only event sequence	Source of truth for agent state and behavior
LogAct	Intent, Vote, Commit, Abort, Result	Shared-log substrate for safe execution and recovery
Responsible ML LogAction	Training, deployment, inference, and audit events	Continuous auditing and accountability
Cognitive-logs	Action rows with who, cause-S, cause-N	Database-driven episode representation and reasoning
Workflow abstraction systems	Interaction histories and action sequences	Reusable analytics and high-level workflow inference

This suggests a family resemblance rather than a single fixed standard. Across the surveyed work, LogAction consistently marks an inversion: the log ceases to be an after-the-fact record and becomes the medium through which state, control flow, policy, provenance, and later reasoning are expressed (Fukada, 2024).

2. Event-sourced and shared-log architectures

The strongest formulation is event-sourced. ActiveGraph models the log as a finite sequence

$L = (e_1, e_2, \dots, e_T),$

with each event informally carrying id, type, payload, actor, caused_by, and timestamp. The working graph is a deterministic projection

$G = P(L),$

implemented as a fold over the event sequence. Graph state is never mutated directly from user or behavior code; the only way the graph changes is by replaying the log through this fold operation. Behaviors are reactive rather than imperative: each behavior has a subscription over event type, optional payload predicate, and graph pattern, and can only create objects, create relations, patch objects, or call tools and LLMs by emitting new events. “No component instructs another; coordination happens entirely through the shared graph” (Nakajima, 21 May 2026).

LogAct adopts the same inversion but expresses it as a shared-log state machine. Its AgentBus is a linearizable, durable, append-only shared log whose typed entries include InfIn, InfOut, Intent, Vote, Commit, Abort, Result, Mail, and Policy. The agent is deconstructed into Driver, Voters, Decider, and Executor. The Driver appends InfOut and Intent; Voters append Vote; the Decider appends Commit or Abort; the Executor appends Result. The action lifecycle is therefore log-mediated from intention to execution, rather than hidden inside an imperative control loop (Balakrishnan et al., 9 Apr 2026).

A distinct but structurally related formalization appears in cognitive-logs. There, actions are first-class objects and the primary key of the main event table. Core morphisms include

$$\text{who} : \text{Actions} \to \text{Participants},$$

$$\text{cause-S} : \text{Actions} \to \text{Actions},$$

and

$$\text{cause-N} : \text{Actions} \to \text{Actions}.$$

Episodes are finite subcategories of the global e-log, and reasoning proceeds through functors between e-logs and s-logs. This gives LogAction a categorical interpretation in which actions, participants, causes, and time are all explicit database objects rather than latent features (Fukada, 2024).

3. Auditability, replay, forking, and safety controls

LogAction systems are typically motivated by properties that conventional retrieval-and-summarization memory systems do not provide. In ActiveGraph, the single design decision that makes the log primary yields deterministic replay of any run from its log, cheap forking that branches a run at any event without re-executing the shared prefix, and end-to-end lineage from a high-level goal down to the individual model call that produced each artifact. Deterministic replay is governed by a determinism contract: behavior bodies must not read random numbers directly, read the wall clock, generate fresh UUIDs outside the runtime, perform arbitrary I/O outside the framework’s tool/model wrappers, or depend on mutable global state that can differ between runs. Strict replay compares the recomputed event stream against the recorded one event by event; a successful strict replay is a proof that the run is reproducible under the determinism contract (Nakajima, 21 May 2026).

The same log-centricity makes forking a primitive operation. Given

$L = (e_1, e_2, \dots, e_T),$

a fork at cutoff $k$ constructs

$L' = (e_1, \dots, e_k, e'_{k+1}, \dots, e'_{T'}).$

Event IDs up to $k$ are literally shared; only post-fork events enter a new monotonic ID space. Because model and tool responses are content-addressed and cached, the shared prefix is replayed without external calls. This makes structural diff between parent and fork a first-class comparison mechanism rather than an ad hoc experiment protocol (Nakajima, 21 May 2026).

LogAct frames the same concerns in safety and recovery terms. Because each Intent becomes visible in the shared log before execution, Voters can stop actions prior to execution, and the Decider can enforce quorum policies such as on_by_default, first_voter, or boolean combinations over voter types. The paper defines consistency in terms of faithful execution of the committed intention sequence, safety in terms of environment states satisfying administrator invariants, and enforced-safety in terms of the approximation actually implemented by Voters and Decider. Recovery is component-specific: Driver, Voters, and Decider use snapshot-plus-replay; Executor recovery is semantic rather than purely replay-based, because re-executing arbitrary environment mutations is not generally safe (Balakrishnan et al., 9 Apr 2026).

Responsible ML logging extends the same audit logic to model lifecycle governance. The stated requirements are to capture key lifecycle events, record responsible-AI metrics alongside performance metrics, support traceability, be structured and machine-readable, and be continuous. The paper specifically notes that fairness metrics, privacy metrics such as $\epsilon,\delta$, explainability metrics such as SHAP values and feature importance, and security/safety indicators are “almost never logged” in the 85 GitHub ML projects it analyzed, despite their necessity for reconstructing how a decision was made and whether it complied with policy at that time (Foalem et al., 25 Aug 2025).

4. Action-centric representations and workflow abstraction

A second major lineage treats LogAction as a way to abstract, compare, and reason over human or machine activities. Cognitive-logs define a cluster of databases consisting of e-logs for dynamic events, be-logs for static relations, and s-logs for abstract episodes or rules. Because actions themselves are also participants,

$G = P(L),$0

actions can be acted on, compared, and mapped by functors. Deductive reasoning is performed by seeking a functor from a concrete e-log into an s-log; missing actions required to complete the mapping become predicted future actions. The same machinery supports isomorphism, embedding, similarity, and abstraction of stories or episodes (Fukada, 2024).

WorkflowView uses LLMs to abstract low-level action sequences into high-level activities and workflows through a three-layer hierarchy: raw action sequence to detailed natural-language description, detailed description to succinct high-level activity or task description, and optionally high-level activity to a category or label. The framework is evaluated on three tasks: zero-shot task description reconstruction from browser logs, where it achieves high semantic similarity with $G = P(L),$1; few-shot student dropout prediction using MOOC interaction logs, where it reaches weighted $G = P(L),$2 with only five few-shot examples; and anonymized, privacy-preserving analysis of AI tool integration within document workflows in Microsoft Word (Verma et al., 12 Jun 2026).

A related interaction-history view appears in visual analytics. “Recording Reusable and Guided Analytics From Interaction Histories” describes a decision tree whose node embeds visualizations and guide to define a visual analysis task. Analysts drag recorded visualization states from a browsing history into task nodes, add guides and radio-button decisions, and thereby convert interaction logs into reusable analysis workflow templates. Guided Analytics then replays these task nodes as stepwise visual analysis pages with embedded charts and explicit decision points, making interaction histories a medium for best-practice transfer rather than mere provenance (Kim, 2021).

5. Log-based detection, generation, and expert reasoning

In observability and software operations, LogAction also names techniques that operate directly on log events or log-derived representations. ADLILog uses log instructions from the source code of 1000+ GitHub projects to build an anomaly detector that is unsupervised with respect to the target system. The method combines log instructions and target-system logs in a two-phase learning procedure and, according to the paper, outperforms related approaches by up to 60% on the F1 score while maintaining unsupervised design, efficient model updates, and small model sizes (Bogatinovski et al., 2022).

A different anomaly-detection use of the term appears in “LogAction: Consistent Cross-system Anomaly Detection through Logs via Active Domain.” That framework combines transfer learning and active learning in an active domain adaptation pipeline. It trains a base model on labeled source-system logs, then uses free-energy-based sampling and uncertainty-based sampling to choose target-system logs near the source–target distribution boundary and the decision boundary. Across six source–target combinations, the reported average target-side performance is 93.01% F1 with only 2% of manual labels, and the method outperforms some state-of-the-art methods by 26.28% (Duan et al., 29 Sep 2025).

LogAction also intersects software instrumentation. LoGFiLM fine-tunes Meta-Llama-3-8B-Instruct for automated generation or completion of full log statements, decomposing the task into position, level, and content. On the authors’ dataset, LoGFiLM-single reports PA $G = P(L),$3, Adjusted PA $G = P(L),$4, LA $G = P(L),$5, CLA $G = P(L),$6, and C-BLEU-DM $G = P(L),$7, outperforming GPT-4 on several logging-specific metrics; the paper further reports that broader contextual ranges surrounding log statements improve position and level prediction (Zhang et al., 2024). LEONID addresses whether a method needs additional log statements, supports injection of multiple log statements, and combines deep learning with information retrieval to improve message generation. The Need4Log classifier reaches $G = P(L),$8 accuracy across several class-imbalance settings, and the multi-log injector achieves about 23.5% correct full-method predictions overall (Mastropaolo et al., 2023).

At the reasoning layer, LogReasoner enhances LLMs for anomaly detection, log semantic matching, potential failure prediction, and root cause analysis through coarse-grained enhancement of expert thinking and fine-grained enhancement of specific steps. It first distills high-level expert thoughts from troubleshooting flowcharts and existing tasks, then performs solution-level fine-tuning and preference learning on corrected reasoning traces. The paper reports that LogReasoner significantly outperforms existing LLMs and achieves state-of-the-art performance on the evaluated tasks, with especially large gains on root cause analysis and anomaly detection (Ma et al., 25 Sep 2025).

6. Constraints, trade-offs, and research directions

The literature is explicit that log-centric designs incur costs. ActiveGraph notes author burden, storage cost, replay cost, and external side effects: behavior authors must respect the determinism contract; model and tool responses are logged, so long runs consume more storage; very long logs can be expensive to replay; and tools with side effects still change the world on first execution even if their record is replayable later (Nakajima, 21 May 2026). LogAct adds a different systems constraint: multi-agent concurrency over shared external environments is largely left to higher-level coordination, such as sharding resources across agents, role-based access, or locks, and semantic recovery remains best-effort rather than a full rollback mechanism (Balakrishnan et al., 9 Apr 2026).

Privacy and governance constraints are equally prominent. Responsible ML logging emphasizes privacy and data minimization, secure storage, access control, and retention policies for logs that may themselves contain sensitive information. It also identifies open research questions on standardizing logging schemas for responsible AI, automating logging of fairness, privacy, and explainability metrics from existing libraries, and integrating logging with testing, monitoring, and external audits (Foalem et al., 25 Aug 2025). WorkflowView similarly recommends informed user consent, high-level behavioral abstractions rather than sensitive content, and, for future multimodal variants, on-device inference and privacy-preserving summaries (Verma et al., 12 Jun 2026).

Several lines of work also expose domain-specific limits. LoGFiLM is effectively Java-specific because its high-quality issue-linked training data are predominantly Java logging data; LEONID is restricted to Java with Log4j and SLF4J; and WorkflowView depends on informative action names rather than opaque identifiers (Zhang et al., 2024). LogReasoner, despite strong results, still faces hallucinations, dependence on expert flowcharts and teacher models, and limited deployment discussion for latency-critical production monitoring (Ma et al., 25 Sep 2025). These constraints suggest that LogAction remains less a finished standard than a research program: a move toward systems in which logs are durable interfaces for action, reasoning, accountability, and adaptation, but whose full guarantees still depend on better schemas, stronger safety layers, richer retrieval or verification, and more principled treatment of privacy and external side effects.