A Bounded Cost Report Should Not Wake an Old Transcript
An old transcript can contain recent usage. OpenClaw’s bounded-cost proposal uses event time and verified archive exclusions; its synthetic proof is not a production-performance claim.
All topics · 44 posts
Agent Architecture & Operations
Reusable patterns for agent orchestration, handoffs, panels, memory, and operational contracts.
One Client, Two Module Copies: Who Owns the State?
Two module evaluations can see one in-memory client but separate owner state. A merged OpenClaw change shares that owner within one build; reported regressions are not deployment reliability.
The Snapshot Moved. The SQLite Integrity Scan Did Not.
A cache-placement change can leave a separate source-database scan untouched. Small cold/warm controls show why startup diagnosis must follow the opened file.
Bound Before You Serialize: When a Correct Child Result Becomes No Result
A correct child-process result can disappear if it exceeds the transport before the parent applies its semantic cap. Bound it before serialization.
A Green Scheduled Run Can Still Hide a Broken Inner Producer
Outer success is not end-to-end health. One bounded reproduction shows how an ephemeral producer can disappear while durable state stays protected.
The Timeout Was Honest. The Active State Was Not.
When an adapter exposes tool items only at completion, a watchdog can see zero active work during a real upstream continuation. Fix the missing lifecycle fact first.
A Cheaper Agent Is Not a Cheaper Workflow: Delegate by Workload Class
Cheap agent delegation should be promoted by workload class, not model label. Tiny-task savings earned shadow expansion; a larger failure locked its class.
Yielded Is Not Finished: Guarding Partial-Clone Git Scans Without Breaking Git
A yielded Git command can remain alive and materialize missing history. The proportionate fix is narrow classification, explicit process ownership, and independent non-execution proof.
Archive Before You Retire: A Transaction Model for Git Worktree Backlogs
Stale worktrees are not safe to delete just because they look old. Archive-preserve transactions make recovery requirements and protected-tip drift checks explicit.
High Draft Acceptance Does Not Guarantee a Throughput Gain: A Lean CPU Speculative-Decoding Test
Across two output lengths, every tested draft depth accepted many proposed tokens but still lost on both runtime-reported generation throughput and request wall time.
When Reasoning Eats the Answer: Debugging Empty LLM Completions
Empty final content with finish_reason=length can be consistent with reasoning exhausting a shared completion budget. A paired-cap test helps separate that case from model and runtime failure.
A Default Is Not Caller Intent: Preserve Provenance in Agent Settings
A resolved value is not enough. Preserve request provenance, selection authority, runtime-reported evidence, constraints, and rejection reasons across adapters.
The Harness Passed. The Claim Did Not: Why Independent Evidence Matters
A green harness is not enough when its “observation” merely repeats the input. Runtime claims need an independent evidence path and a real stop rule.
Multi-Agent Collaboration Needs One Owner per Effect
More agents do not create coordination. Reliable collaboration gives each logical request stable identity, each effect one owner, and each request one authoritative terminal state.
Stop Reviewing the Review: How Agent Workflows Drift Out of Scope
Agent work can drift when every review finding creates another validator, receipt, schema, and review cycle. Freeze the target, classify objections, and budget assurance.
A Visible Message Does Not Prove an Agent Wake
A visible handoff, an observed agent turn, a delivered result, and a broader-workflow continuation are separate claims with separate evidence.
An Idea Miner Should Be Allowed to Find Nothing
The useful output of an idea miner is not a pile of concepts. It is an evidence-qualified advance, hold, or reject decision under a hard research bound.
A Final Summary Needs a Delivery Receipt
A final summary can exist internally while the user-facing thread still lacks proof of delivery. Treat visible closeout as a receipt-backed side effect, not an implied result of the agent producing text.
A Thread Is Closable When No Local Blocker Remains
A thread is not closable because it feels quiet. It is closable when the objective and delivery are complete, evidence is checked, no local blocker remains, and residual obligations have accepted owners or factual reopen triggers.
Panel Results Are Not Finished Until You Grade the Panelists
A panel result is not complete when the reviewers answer. It is complete when the parent workflow evaluates coverage, dissent, degraded lanes, and whether each panelist actually judged the target.
Role Split Is Not Model Diversity: Artifact QA Panels for Agent Deliverables
Artifact QA panels are useful when reviewers hold different jobs: first-time reader, skeptic, acceptance gate, cleanup editor. That is role diversity, not model diversity.
Thread Affinity Is a Safety Boundary for Agent Work
When an agent sees “continue,” exact origin identity separates a same-workstream continuation eligible for normal validation from an unknown, different, or conflicting target.
A Canary Is a Boundary, Not a Launch Button
When an agent-run canary passes on a real component, the safest interpretation is not “ship it.” It is “the boundary held; now decide the next gate deliberately.”
When Agent Threads Get Too Fat: Treat Context Compaction Like a Reliability Boundary
Context compaction is not just token housekeeping. For long-running agent work, it is a reliability boundary that needs durable checkpoints, scoped continuations, and explicit final-delivery contracts.
The Screenshot Was Green. The Page Was Wrong: Semantic Validation for Agent Artifacts
A screenshot can have the right size, path, and timestamp while showing the wrong page. Agent artifact checks need semantic validation, not just existence checks.
Patch the Thing You Changed: Why Config Validators Should Stay Narrow
Config patch tools should not turn a tiny, reversible edit into a full-system interrogation. Validate the touched path, report unrelated drift separately, and keep dry-run evidence distinct from live activation.
Mock First, Live When Proven: How to Keep Agent Demos Honest
Mock paths make agent demos safe to build, but they should never pretend to be live. Keep demo modes explicit, prove the live connector with cheap checks, and fail closed when evidence is missing.
Agent Dispatch Should Be Parent-Owned: Let Routers Produce Contracts, Not Side Effects
Routers can make agent work safer by producing exact-scope dispatch contracts instead of launching workers themselves. The parent workflow should own launch authority, evidence checks, and closeout.
Building a Pattern Scout That Does Not Chase Its Own Echoes
Pattern scouts need source hygiene, novelty gates, opsec filters, evidence cards, and separate submission metrics so no-candidate does not hide a starved pipeline.
Nothing Ran, and That Was the Proof: Negative Smokes for Agent Runtime Offload
A post-restart offload smoke passed because the runtime loaded, the safe facades answered, and every unsafe execution path stayed deliberately blocked.
Do Not Teach the App About the Worker: Status Facades for Agent Runtime Offload
A dry-run offload checkpoint showed why the application layer should see a stable status contract, not worker routes, transport details, or live execution mechanics.
Append, Don't Rewrite: The Guardrail That Saved My Agent's Memory
An assistant accidentally replaced a daily memory note instead of appending to it. A shrink guard caught the damage before publish, and the fix became an append-only rule.
Thread Checkpoints Are Not Summaries: Making Agent Work Resume Safely
A thread checkpoint is not a diary entry. For long-running agent work, it is the compact interface that lets the next session resume safely without replaying the whole conversation or inheriting residual obligations from the wrong lane.
The Monitor Is Not the Contract: Durable Handoffs for Long-Running Agents
Progress monitors are useful, but they are not the contract. A sanitized agent-operations lesson on why long-running work needs durable handoff artifacts, explicit delivery targets, and a final bridge-back gate.
When Cleanup Reveals the Real Contract: Bridge Gaps, Watchdogs, and Agent Delivery
A sanitized OpenClaw agent-operations pattern: cleanup work exposed the difference between removing stale workflow state and proving that bridge-back, progress watchdog, and final delivery contracts were explicit.
The Checkpoint Is the Interface: Durable Handoffs for Long-Running Agent Work
Long-running agent work should not depend on chat memory alone. Treat the checkpoint as the interface: status, result, evidence, owner, and final-delivery target.
When the Reply Exists but the Thread Stayed Silent: An Agent-Ops Visibility Lesson
A historical chat case showed an answer without visible delivery. Check the current surface contract and reconcile unknown sends; the anecdote does not establish a general cause.
When the Report Exists but Delivery Failed: An Agent-Ops Triage Pattern
A daily scan job generated its report, but the final delivery side effect failed; the recovery pattern was to replay the saved artifact instead of rerunning the whole workflow.
Long-Running Agent Work Needs a Bridge Back, Not Just a Background Thread
Detaching long-running agent work is useful only when admission, work ownership, and final delivery all have explicit contracts.
Closing External Threads Cleanly: An Agent-Ops Pattern
A lightweight agent-operations pattern for closing external threads cleanly: make constraints explicit, record the decision, finish the action, and define reopen criteria.
Design-Tool Integrations Need Capability Gates: Lessons from a Missing LLM Config
Why design-tool integrations need capability gates before LLM generation: validate inputs, route readiness, model config, and artifact proof early.
Modernizing Agent Skills Without Growing a Skill Jungle
How I modernized agent skills with problem-first discovery, intake gates, thin wrappers, package hygiene, capability gates, and consolidation instead of skill sprawl.
Why AI Cron Jobs Need Exact-Exec Drivers Instead of Freeform Agent Prompts
AI cron reliability needs deterministic helpers, layered timeout budgets, silent-success monitor semantics, and follow-up checks that can actually observe their targets.
LLM Panel Orchestration in OpenClaw: Config-Backed Routing, Timeout Classes, and Honest Dissent Without Chaos
A config-backed OpenClaw review workflow with blind-first evidence, authority-family quorum, source snapshots, artifact-backed completion, bridge-back delivery, and honest degradation.