The Log Is The Agent - Ishaan Sehgal, Omnara

Key Concepts

• The Log: An append-only, durable event history of an agent (inputs, outputs, tool calls, results, failures).
• Agent Identity: The concept that an agent is defined by its data (the log) rather than the runtime, model, or hardware.
• Projections: Views derived from the log (e.g., UI, context windows, debugging, auditing).
• Compaction: A lossy process of summarizing the log to fit within finite model context windows.
• Log Lock-in: The risk of providers owning the agent's history, which is the most valuable and intimate asset.
• Disposable Workers: The architectural pattern where execution processes are stateless and can be swapped or restarted because the state resides in the log.

---

1. The Core Thesis: The Log is the Agent

Ishaan, CEO of Amnara, argues that current industry abstractions for AI agents are flawed. Most developers equate an agent with the model or the execution environment. He posits that these are merely "interpreters" of the agent.

• The Analogy: Comparing an agent to a video game character (e.g., in Skyrim). The console, controller, and game engine are the runtime, but the "character" is the save file. If the hardware fails, the character persists through the data.
• Definition: The log is the "durable sequence of changes." Every state transition must be written to this append-only history.

2. Architectural Framework: The Log-Centric Loop

The system architecture should be inverted so that the log is the primary source of truth.

• The Loop:
  1. Reconstruct state from the log.
  2. Pass state to the model.
  3. Model proposes an action; append to log.
  4. Tool runner executes action; append result to log.
  5. Repeat.
• Disposable Execution: Because the log holds the state, the worker process is disposable. If a worker crashes, a new one can pick up the session, read the log, and resume exactly where the previous one left off.

3. Addressing Objections

• Compaction: While logs grow indefinitely, context windows are finite. Compaction is necessary but must be treated as a lossy projection. The raw log must be preserved; if you discard the raw log, you lose the agent's history.
• External State: Critics argue that agents change the world (e.g., sending emails, editing files) outside the log. Ishaan clarifies that the log is the agent's view of the world, not a record of the entire universe. It stores the agent's identity and necessary context to resume, similar to how a save file doesn't contain the entire game engine.

4. System Properties Derived from the Log

Treating the log as a first-class citizen enables several structural advantages:

• Reliability: If a process dies during a permission prompt, the prompt remains in the log for the next worker.
• Scalability: Agents are no longer tied to a single machine. One process can manage thousands of agents by reconstructing state from the log on each turn.
• Forking: Because the log is a sequence, one can branch the history to test different models (e.g., Claude vs. GPT) on the same starting state.
• Multiplayer/Collaboration: Sharing an agent becomes a matter of granting access to the log, allowing teammates or managers to observe or intervene in real-time.
• Migration: Moving between providers becomes an "adapter problem" rather than an identity crisis, as the log remains the source of continuity.

5. Ownership and Strategic Implications

Ishaan emphasizes that "Log Lock-in" is the most dangerous form of vendor lock-in.

• The Risk: Managed providers (Anthropic, Google, etc.) want to own the agent loop, memory, and sandboxes. If they own the log, they own the agent—and by extension, the user's personal and company data, workflows, and decision-making history.
• Amnara’s Approach: Amnara is building an open-source managed agent platform where the session log is fully owned and controlled by the user, ensuring that the agent remains portable and transparent.

6. Notable Quotes

• "The thing that actually gives an agent its identity is its log."
• "The log is the durable history that all of these projections can come from. Now, the log itself is not a projection."
• "The deepest form of lock-in is actually log lock-in... the model is replaceable, the runtimes replaceable, the machines are replaceable, the log is the thing that persists."

Synthesis

The fundamental takeaway is a shift in perspective: stop treating the log as an exhaust or a side effect of the system, and start treating it as the system itself. By prioritizing the log, developers can build agent systems that are inherently reliable, scalable, and portable, while avoiding the long-term risks of proprietary vendor lock-in.