Agents fundamentally differ from transactions: they're sessions lasting as long as users want, not discrete workflows with clear endpoints.
Snapshot-restore durability beats replay journaling for long-running agents—replay logs grow unbounded as agent interactions continue over hours or days.
Agent durability requires two separate mechanisms: append-only context logs (LLM messages, tool calls, results) plus VM snapshots for execution state (files, memory, processes).
Firecracker VM snapshots compressed to ~14MB enable sub-second snapshots and ~200ms restores, feasible at 15,000 VM starts per minute.
Seekable compression decompresses only needed memory pages on restore, avoiding full snapshot reload costs and enabling practical cost economics.
Shared-nothing architecture dominated backends for 30 years; agents force a shift to stateful compute infrastructure with persistent execution environments.
Snapshot-restore handles diverse agent capabilities—running dev servers, cloned repos, subprocesses—that can't be durably reconstructed from logs alone.
CRIU process checkpointing has limitations: only captures open files, incompatible with external processes like Chrome or FFmpeg, slower than VM snapshots.
Agent durability enables asymmetric failure recovery: snapshot-and-wait during external delays, or replay context log when machine crashes.
Trigger.dev's FC Run tool provides Docker-like CLI for Firecracker VM snapshotting and restoring, launching as open source for stateful compute workloads.
Eric Allam argues replay-based durable execution breaks down for long-running agents that clone repos and hold in-memory state. Trigger.dev's Firecracker-based implementation uses an append-only context log for code compatibility and VM snapshots for execution state, hitting sub-second snapshots and 200ms restores at scale.
Smart truncation strategy: keep first 100 and last 100 tokens, store middle in memory for agent retrieval—more reliable than naive truncation or summarization alone.
Sub-agents for heavy workloads: delegate data-intensive tasks to specialized agents while keeping main conversation lightweight, preventing context overflow in single agent.
Summarization for context management failed due to inconsistency and lack of control over what LLM deemed important; hybrid truncation+memory approach proved superior.
Long conversation evals catch context failures early: load 10 turns then test the 11th to surface bugs before users report them, avoiding late-stage failures.
Context engineering (not prompt engineering) determines agent success—what the model sees matters more than how you phrase the request.
Agents fail because of insufficient or poor context, not bad prompts; context is now the primary engineering problem, not a secondary constraint.
Context management is a product and UX problem, not purely an engineering one—bad context leads to bad answers and abandoned products.
Long-term memory remains unsolved: current memory store is conversation-scoped; users need cross-session context and ability to reference previously discussed issues.
Context selection still uses heuristics (first/last 100 tokens); no principled budget or clear metrics yet for determining which context is actually important.
Very large prompts and customer system prompts continue hitting provider limits; continued sub-agent decomposition is the emerging pattern for managing scale.
Naive LLM summarization was too inconsistent; full truncation broke reasoning. The working fix: keep the first and last 100 tokens while storing the middle in a retrievable memory store, plus offloading data-heavy tasks like search to sub-agents so the main conversation stays lightweight. Long-session eval (testing turn 11 after 10 loaded turns) caught context bugs before users hit them.
Simpson's Paradox (aggregation illusion): Top-level KPIs can tell opposite stories from segment-level data—improvements hide harmful shifts in product mix, customer quality, or channel composition.
Four-question KPI checklist before reporting: Does it support decisions? What action follows if it changes? Over what time horizon matters? What could make it misleading?
Cobra Effect: Tying incentives to metrics causes people to optimize the KPI itself rather than underlying reality (e.g., support teams gaming satisfaction scores, call centers closing tickets faster without solving problems).
Lagging indicator trap: By the time KPIs turn red and reports refresh, the decision window has already closed—most dashboards default to reporting what already happened, not what you can still influence.
Narrative fallacy in reports: Two correlated lines trigger causation stories in our brains, but correlation often masks coincidence, seasonality, pricing changes, or unrelated market trends—not the campaign you credited.
Local optimization breaks systems: Measuring marketing on leads, sales on conversion, operations on cost efficiency makes each team's dashboard green while destroying overall company performance and customer value.
Short-term bias: Quarterly KPI improvements from aggressive discounts or offers can quietly damage long-term brand value and premium positioning—success this quarter may quietly hurt next year.
Outcome bias distorts learning: Good results from weak decisions get misattributed to strategy rather than luck or favorable conditions, causing organizations to repeat poor processes.
Real question isn't beauty or technical correctness—it's whether the report actually helps stakeholders make better decisions; goal of analytics is improving decisions, not measuring business.
Most dangerous KPIs aren't wrong, just incomplete: Aggregations hide truth, incentives distort behavior, and short-term gains mask long-term damage when KPIs lack safeguards and context.
Yannis organizes dashboard failure modes into three buckets—measurement illusions (Simpson's paradox, mix shift, lagging indicators), behavioral traps (Goodhart's Law, Cobra effect, outcome bias), and system/time traps (local optimization, short-term bias)—then proposes a four-question checklist to run before any metric reaches an executive dashboard.
Self Flow is a self-supervised training method that eliminates external encoders by combining representation learning and generation in a single flow using student-teacher noise levels.
Self Flow trains one model jointly across multiple modalities—images, video, audio, and actions—without separate specialized encoders for each, enabling true multimodal generative AI.
Models trained with Self Flow outperform baselines in text rendering, anatomy, and video coherence while converging faster and still reducing loss after baseline plateau.
Flux Klein generates and edits images in under 500ms (editing) and 300ms (generation)—near real-time—while matching or exceeding quality of slower open-source competitors like Kwen at 15+ seconds.
Self Flow enables joint video-and-audio generation from a single model trained on images, video, and audio without mode-specific alignments or encoder compromises.
Black Forest Labs is expanding beyond image generation toward physical AI, training models to predict robot actions and movements for automation and self-driving applications.
Self Flow removes the scaling ceiling imposed by fixed external encoders, allowing student and teacher models to scale up together without encoder limitations.
Prior encoder-based training showed unpredictable alignment failures—DinoV3 outperformed DinoV2 technically but worsened generative model performance with no clear explanation.
World models trained via Self Flow simulate geometry, relationships, and world interactions to enable training agents in generative environments for scaled robotics and manufacturing automation.
Real-time multimodal generation enables interactive visual engines for gaming and film where creators render content at the speed of prompting, not waiting seconds or minutes.
Self Flow uses dual noise streams—one heavily noised, one lightly noised—to jointly learn generation and representation in a single model, eliminating external vision encoders. Converges faster, fixes anatomy and text artifacts, and generalizes across images, video, audio, and robot action prediction.
