Apache Maka turns the agent run into an append-only log (2026)

On August 13, 2026, Apache Maka entered the Apache Incubator as a local-first AI agent runtime and workspace.1 Two weeks later, the repository was still shipping the same product bet: treat every agent turn as a durable fact stream—messages, tool calls, tool results, permission decisions, and how the turn ended—rather than as a chat transcript that disappears when the window closes.2 3

If your product already runs agents that edit files, call tools, or need human approval mid-run, this is a one-week architecture pilot: keep an append-only runtime event log as the source of truth, and rebuild the UI and the next model prompt from that log.

The signal

Apache's incubator page records Maka's entry date as 2026-08-13 and describes the project in one line: a local-first agent runtime that records model messages, tool calls, tool results, permission decisions, and termination events in append-only logs.1

The public repository matches that description. Maka routes Desktop, TUI, CLI, and evaluation through one Runtime Host. Model messages and tool calls are written as recoverable execution facts on the machine; the UI and the next model call are views of that record, not the only copy. Context can drop old tool output from the next prompt without deleting the saved evidence.2 4

The August 25 commit feed keeps that contract concrete. One change commits admitted user messages into the durable transcript before execution starts, so a crash after queue admission can recover the successor turn once.3 Another lands durable local deployment ownership on Runtime Host.5 A third settles a live turn from the persisted terminal state rather than from a temporary UI flag.6

Related research is moving the same way. LEDGER (arXiv:2608.18398, submitted 19 August 2026) builds claim-to-evidence trace graphs over observed agent sessions so reviewers can follow which actions and artifacts support a conclusion.7

What the tech is

Maka's runtime answer is short:

State at time t is a projection over an ordered Runtime Event Log.

The project's runtime-core note, last verified 2026-08-23, states the rule directly: the Runtime Event Log is the semantic source of truth for agent interaction; Sessions, Runs, the UI, model context, and recovery are consumers of that log.8

A Runtime Event is richer than role + text. It carries identity (sessionId, runId, turnId), ordering, source role, content (text, thinking, tool call or result), control actions (permissions, artifacts, usage), correlation IDs that pair a tool call with its result, and lifecycle flags such as partial stream fragments versus durable or terminal facts.8

Different projectors read the same log:

Projector	Job
Model-history	Build the messages for the next model request
UI / session	Show conversation, tool activity, and turn state
Terminal classifier	Decide whether a run completed, failed, or stopped
Recovery	Rebuild state after a process exit
Context / compaction	Shrink the working prompt without erasing history

Permission requests and decisions sit in the log as actions, not as chat text that pretends to be a decision. A terminal event closes a run explicitly, so a late provider chunk cannot rewrite a stopped run as "completed."8

The product shell matches that design. Desktop is the daily surface; TUI and maka run share the same workspace and model connections; evaluation goes through Runtime Host for Maka subjects. Built-in tools cover Read, Write, Edit, Bash, Glob, and Grep. Tools that leave the sandbox need approval. Sessions, settings, and run records stay local by default under Electron userData, with live state in runtime.sqlite.2

The problem it solves

Agent products fail in ways chat products rarely do.

A run can park on a permission prompt, stream tool output, time out, get cancelled, crash mid-tool, or keep receiving provider events after the user hits Stop. The UI needs live activity. The next model turn needs trustworthy history. Support needs a path that shows which tool wrote which file and which human approved it. A chat bubble store answers none of those cleanly once the transcript is compacted, the process restarts, or two clients share one queue.

The causal chain is straightforward:

The product stores the agent run as a chat transcript or as free-form application logs.
Compaction, crashes, multi-client queues, and permission gates break the transcript as a reliable history.
Reviewers cannot reconstruct tool side effects, approvals, or terminal status without guesswork.
An append-only event log records those facts as typed events; UI and model context become rebuildable projections.

Maka's own framing of the runtime problem is that an agent loop mixes streams, tool side effects, user intervention, and process failure, and the system must keep a fact history that can be interpreted again after those interruptions.8

How to build with it

You do not need to ship Maka to test the pattern. You need one durable log and three projectors.

Pilot checklist

Pick one agent job with side effects. Choose a workflow that already calls tools, writes files, or waits on human approval—for example issue triage with repo edits, or support actions that hit internal APIs. Write the baseline: first-pass task success, mean time to recover a stuck run, and how long a human spends reconstructing "what the agent did."
Define the event schema before the UI. At minimum, record user message, model message (and thinking if you keep it), tool call, tool result, permission request, permission decision, usage, and terminal status. Give every event a monotonic id, timestamp, sessionId, runId, and turnId.
Pair tool calls by stable id. Store toolCallId on both the call and the result. Refuse to mark a run successful if a call has no result and no explicit cancel or failure event.
Admit before you execute. Persist the accepted user message (and any queued follow-up) before the model loop starts, the way Maka's admission path commits the transcript before root handoff.3
Project twice from one log. Build the next model history from non-partial, model-visible events. Build the UI timeline from the same events plus permission and terminal facts. Do not let the chat renderer be the only store.
Compact the prompt, keep the ledger. When context is tight, omit old tool bodies from the next model request while leaving the full events on disk. Maka states this split explicitly: shorter context is not deleted history.2 8
Close runs with a terminal event. Stop, failure, and success are facts in the log. UI "running" state must come from the latest durable terminal fact after restart.
Gate side effects outside the sandbox. Require an explicit permission event before shell, network, or write tools that leave the workspace. Store who approved and when.

Thin skeleton

type RuntimeEvent =
  | { type: "user_message"; id: string; ts: string; sessionId: string; runId: string; turnId: string; text: string }
  | { type: "model_message"; id: string; ts: string; sessionId: string; runId: string; turnId: string; text: string; partial?: boolean }
  | { type: "tool_call"; id: string; ts: string; sessionId: string; runId: string; turnId: string; toolCallId: string; name: string; args: unknown }
  | { type: "tool_result"; id: string; ts: string; sessionId: string; runId: string; turnId: string; toolCallId: string; ok: boolean; body: unknown }
  | { type: "permission"; id: string; ts: string; sessionId: string; runId: string; turnId: string; toolCallId: string; decision: "allow" | "deny"; actor: string }
  | { type: "terminal"; id: string; ts: string; sessionId: string; runId: string; status: "completed" | "failed" | "stopped"; reason?: string };

// append-only store; projectors never rewrite history
async function append(event: RuntimeEvent): Promise<void> { /* write to SQLite/JSONL */ }
function projectModelHistory(events: RuntimeEvent[]): Message[] { /* drop partials; keep paired tools */ }
function projectUiTimeline(events: RuntimeEvent[]): TimelineItem[] { /* include permissions + terminal */ }

If you want to exercise the reference implementation, Maka's README documents a source build path: Node.js 22.19+, npm ci, then npm run dev for Desktop on Apple Silicon, or npm run build plus the CLI for a non-interactive turn. The project has not published an Apache source release yet; treat pre-incubation binaries as convenience artifacts, not ASF releases.2

Weekend experiment

Take 15 real tasks from one agent workflow that already has tool use.

Run each task twice:

Path A: your current store (chat messages only, or application logs).
Path B: an append-only runtime event log with the schema above and two projectors (model history + UI timeline).

For each task, force three interruptions: kill the process mid-tool, deny one permission, and stop the run after the first tool result. Then ask a teammate who did not watch the run to answer four questions from the stored record alone:

Which tools ran, in order, with which arguments?
Which permission was denied, and by whom?
Did the run complete, fail, or stop?
Can they rebuild a safe next model prompt without replaying unsafe tool bodies?

Score yes/no per question. Also record recovery time after the process kill and input tokens on the follow-up turn.

A useful result is a small table: Path B should win on questions 1–3 if the log is complete; Path A often wins on implementation speed and may still win on tokens if Path B naively dumps every event into the prompt. The product decision is whether recovery and audit accuracy are worth the projector work.

Watch-outs

Incubation and platform limits. Maka is incubating; macOS Apple Silicon is the early public Desktop tier, Linux is not supported yet, and Windows is an unsigned preview. Pin a commit for any pilot and expect data-format change.1 2
Semantic replay is not bit-exact wire replay. Maka reconstructs interaction facts and runtime state. Full deterministic provider replay would also need versioned prompts, tool schemas, projection policy, and request shape. Do not promise auditors "exact HTTP replay" from the message log alone.8
Logs hold secrets. Tool results and file contents can include credentials and customer data. Scope retention, encrypt at rest, and keep the credential vault out of the renderer—the same separation Maka documents for local secrets.2
Projection bugs are product bugs. If the UI reads a different store than recovery does, you will ship ghost "running" sessions and missing tool results. One log, many views.
Audit graphs are a second layer. An event log answers what happened. Claim-to-evidence graphs such as LEDGER answer whether a final answer is supported. Add the second layer only after the first is complete.7

The build decision for this week is small: take one agent workflow that still treats the chat pane as the database, give it an append-only event log with terminal and permission facts, and measure whether a teammate can reconstruct the run after a crash. If they cannot answer which tool wrote the file and who approved it, the runtime needs a ledger before it needs a larger model.