OpenClaw's near-burnout, agent teams that ship 99.9% of PRs, and the math behind prompt caching

Steinberger walks through the full arc of OpenClaw — from a personal WhatsApp relay to 4.7M weekly downloads — and is unusually candid about what broke: security reports that ate months, 9,500 configuration permutations that killed velocity, and a provider pulling subscriptions with 24 hours' notice. This is a field report on the real failure modes of viral developer tools, not a victory lap. Anyone building on top of a single model provider should hear the dependency-risk section.

• Your dependencies' business model is your business model — over-optimizing for one provider (Claude) became an existential risk when subscriptions were pulled with 24 hours' notice
• Configuration explosion is a velocity killer: 9,500 config permutations made it impossible to test combinations or ship without breaking changes
• Press claimed 20% of OpenClaw shells were malicious; the actual figure was 0.3% — but the security narrative still crushed months of momentum
• Fun is velocity: the weeks he enjoyed building, the product visibly improved; the weeks he didn't, they just shipped config options

Nineteen minutes of concrete architecture decisions from a team that generates 99.9% of its PRs with agent assistance and burns 1.5 billion tokens a month. The lessons are specific and transferable: stay model-agnostic because the best model changes weekly, run agents in isolated cloud environments so credentials stay out of reach, and benchmark on your own codebase because SWE-bench's Python bias tells you nothing about your Rails app.

• Benchmark agents on YOUR codebase — public benchmarks like SWE-bench are Python-heavy and their Rails codebase showed very different model rankings
• Isolated cloud environments solve both 'laptop anxiety' (closing the lid stops work) and the security problem of agents touching credentials they shouldn't
• Same agent session across Slack, desktop, mobile and GitHub prevents context siloing — every human interface becomes an agent interface
• Codex ran 4x more sessions than Claude Code at lower total cost in their stack

The most immediately actionable seventeen minutes of the week. It explains the mechanic most agent builders get wrong: the LLM reprocesses your entire conversation on every turn, so costs compound quadratically — and a single timestamp in a dynamic system prompt invalidates your whole cache downstream. The worked example takes a 200K-token session from $41 to roughly $4 with correct caching.

• A 50K-token session actually processes 50K + 51K + 54K... tokens cumulatively — cached tokens cost ~10% of full price across major providers
• Dynamic system prompts (timestamps, changing working directories) invalidate the entire cache downstream — a silent, expensive bug
• Cache expiry differs by provider: OpenAI 1 hour, Anthropic 5 minutes on the API but 1 hour in Claude Code
• OpenAI and Hugging Face Inference cache automatically; Anthropic and Gemini require you to enable it explicitly

Crivello goes deeper into production agent memory architecture than almost anyone talking publicly: a background memory agent updating a file-based knowledge graph every 15 minutes, tree structures that reach billions of tokens within two LLM calls, and 85% cache hit rates from careful prompt design. There's also a striking data point on the economics — internal inference spend approaching payroll — and a genuinely contrarian policy take from someone whose own product runs on DeepSeek. At over two hours, jump to the technical sections.

• A background 'napping' memory agent runs every 15 minutes to update a file-based knowledge graph, with separate personal and workspace memory layers
• Tree data structures with ~100 children per node let the system reach billions of tokens of context within two LLM calls
• Lindy's internal inference spend is approaching payroll cost and will likely cross over in 3-6 months, with productivity tripling while headcount stays flat
• Context beats raw intelligence: a smart agent without your company's context is less useful than a mediocre coworker with full context

A tight case study from Harmonic on rebuilding their agent product and quadrupling week-1-to-week-4 retention in the process. The core lesson generalizes to any agentic product: anything you render to the user that isn't in the messages list or an agent-accessible file system is invisible to the model, and that invisibility silently degrades every follow-up interaction. Sixteen minutes, one clear design principle, immediately applicable.

• Switching from a complex multi-node query graph to Deep Agents produced a 4x retention improvement from week one to week four
• The critical UX rule: if users see data the agent can't access, the agent loses the ability to reason about it in follow-ups
• Embed visualizations directly in assistant messages with delimiters so the model retains full visibility and can modify them on request
• Design smell test: if you're telling the model to 'trust' that something is rendered, you've probably made it invisible to the agent