ParticleDB Forgot Successful Writes

If You Only Read One Thing

A successful database write is weaker evidence than it sounds. Jepsen’s ParticleDB investigation found a database acknowledging writes it later lost. Arca’s long-horizon agents depend on persisted obligations to keep work moving between human decisions. Together, they expose an overlooked dependency: better agent memory helps only when the software underneath preserves the events that memory claims to describe.

ParticleDB Lost Writes Without a Crash

ParticleDB’s failures make a blunt case for checking AI-built software from the outside. A successful response from a storage tool can be false evidence of progress. An agent that trusts it may confidently continue from an event that never became durable.

Kyle Kingsbury’s October 31 Jepsen report, amplified by practitioners over the weekend, documents 96 issues across tested ParticleDB versions. All but three occurred on healthy single-node systems. This wasn’t mainly a story about exotic failures across a distributed cluster.

In one test, 31 of roughly 20,000 keys lost acknowledged writes. A value was visible after a successful commit, then disappeared as other writes replaced it. For an agent recording completed work, that could mean repeating an action or losing the record that prevents repetition.

ParticleDB combines several data services for AI applications. Orkes built it with LLM assistance, and Kingsbury reports that generated repair claims repeatedly failed verification. The problem extends beyond whether a model writes a correct function: a database must preserve relationships between operations over time.

Ordinary tests can miss that relationship. A test that writes a value and immediately reads it back may pass before a later operation makes the value disappear. A second model reviewing the implementation may never examine that sequence either.

Jepsen’s published test code provides a different reference. It exercises the database and checks histories of operations against the behavior the database promises. The check can reject a system even when individual requests return success. This adds something to the usual agent review loop: acceptance depends on what remains true after subsequent work, rather than the patch or its first successful test.

The report isn’t a controlled comparison of human and AI development. Orkes funded the investigation, most findings appeared fixed during testing, and the company says a later release fixes the remainder. Jepsen hasn’t evaluated that final release. Those qualifications rule out treating 96 as a count of current unresolved defects, or as proof that AI caused each one.

The result still changes what a completion receipt needs to mean. For stateful agent work, “saved” has to survive the operations that follow it. An independently checked run of the later ParticleDB release with no lost acknowledged writes would close the report’s most consequential open question.

Arca Keeps Obligations Alive Between Decisions

A ten-day agent task doesn’t need ten days of uninterrupted reasoning. It needs to remember what’s waiting, who owns the next decision, and which actions remain unavailable. Arca’s production account suggests that managing those pauses matters more than keeping a conversation running.

In an October 31 interview with Latent Space, Arca’s AI lead Aman Singh describes client workflows that can span ten days. The company stores client history, pending actions and responsibility for those actions. Agents do background analysis; human advisors handle trading and money movement.

That separates elapsed time from computation. A task may sit idle while a person responds or another event arrives. Repeatedly asking a model to reconsider the entire conversation would spend inference without supplying the missing decision. A persisted obligation gives the system something specific to resume when circumstances change.

Arca also limits how generated code reaches client data. Singh says the system converts that code into a restricted format, discards the original code, and checks the resulting representation before it reaches the backend. The agent uses a computation sandbox; Singh explicitly says the agent itself isn’t inside that sandbox.

The conversion step deserves attention. Instead of allowing every operation a programming language can express, a service can accept only operations its own format represents. That gives the service a smaller set of actions to inspect. This is an architectural reading of Singh’s account; Arca hasn’t published enough implementation detail to verify exactly which operations its format permits.

Yesterday’s DeepSeek prototype separated incoming context from permission to start work. Arca adds a different production consideration: permission and responsibility have to remain legible while work pauses. A stored plan must identify the human decision still needed, rather than letting another model interpret silence as approval.

Owning this machinery costs engineering time. A managed agent service could remove much of that burden, and Arca hasn’t supplied a controlled comparison showing that its custom system saves money or prevents more errors. Its account supports a design pattern, not a measured performance claim.

The connection to ParticleDB is uncomfortable: a workflow can enforce every approval correctly and still lose the record of what happened. The payoff from persisted obligations depends on those obligations surviving interruption. A resumed client task that retains the pending decision, its owner and completed actions is the observable standard; a coherent conversation alone isn’t enough.

The Contrarian Take

Everyone says: Giving agents persistent memory makes them more reliable over long tasks.

Here’s why that’s wrong: Persistence can preserve an incorrect account just as efficiently as a correct one. ParticleDB’s lost acknowledged writes show why a model’s record of success can diverge from the system’s state. Arca’s design is interesting because its memory includes outstanding obligations and human decisions, rather than just previous prose. Reliability improves when the stored record can be reconciled with what actually happened. More remembered text, by itself, can make an agent more consistently wrong.

Under the Radar

Carbon’s medium effort has a separate price for completed evaluation work. Artificial Analysis added Gemini 4 Carbon Medium on November 1: index score 58 and $6.59 per benchmark task at standard prices. That extends Thursday’s high-effort coverage. It supplies another configuration to compare, while restricted model access still limits immediate substitution.
DeepSeek’s fresh high-effort result lacks a task-cost figure. Artificial Analysis’s November 1 Flash 1017 High entry reports 29 on its current index and 130 million evaluation output tokens. Cost per task is unavailable. Comparing that score with October’s older index result would confuse a changed test with a changed model; cheap listed tokens alone can’t settle the economics.

Quick Takes

Northflank warns that stored secrets may be compromised. Its October 30–31 updates report unauthorized use of customers’ AI keys and advise assuming all environment variables were compromised. Wiz’s October 30 investigation places it among nine platform disclosures, without identifying one shared vulnerability. An agent’s model permissions offer little protection when someone steals the credential underneath them. Northflank hadn’t disclosed the entry route or customer count. (Source)
Sophos connects AI-assisted testing to ransomware operations. Its October 29 investigation links a Cursor-assisted endpoint-testing framework’s infrastructure to subsequent Aur0ra operations. Researchers assess with high confidence that GOLD OGRE used AI for evasion testing and supplied associates with similar technology. This adds a separate observed operation to Saturday’s ARTEX account; it doesn’t quantify how much autonomy or speed AI added. (Source)
Agent-desktop gives UI targets an identity beyond screen coordinates. Vercel Labs’ cross-platform tool reads operating-system accessibility trees and lets agents act on references from a snapshot. Stale or ambiguous references trigger errors instead of silently selecting a replacement target. The released artifact makes that behavior inspectable; it isn’t evidence of a measured completion-rate improvement. Applications still need to expose usable accessibility information. (Source)
Claude Code’s own exit now cleans up shell commands. Version 2.1.316 fixes commands left running on macOS and Linux when Claude Code exits itself, including refused credentials or an archived cloud session. This is separate from the worker-effort setting covered yesterday. A failed agent session could previously leave work consuming resources after the supervising process had gone; process lifetime is part of failure handling. (Source)

The Thread

Agent systems need two receipts for progress: one saying the action was allowed, another showing what changed. Approval records can explain why Arca proceeded; storage histories can show whether a completed action remained recorded. Combining the two creates a further requirement: recovery must reconcile them before repeating work. If an agent sees authorization but no completion record, it can’t safely assume either that nothing happened or that the action succeeded. That ambiguity becomes more expensive as tasks cross days and involve external services. The next useful layer of agent memory may therefore be a way to represent unresolved outcomes explicitly. A system that can say “authorized, outcome unknown” has a better chance of recovering safely than one forced to choose between “done” and “not done.”

Prediction Ledger

Weekly Scorecard

Gemini 4 Argon would reach paid developers outside the initial restricted programs by October 31. Made October 1, medium confidence. Correct: Google’s October 13 API release notes record general availability.
Ollama would ship a stable release supporting Clef by October 31. Made October 2, medium confidence. Condition met, but no predictive credit: version 0.35.1 already supported Clef on September 29, before the forecast.

What I Got Wrong

The Clef call predicted something that had already shipped. I mistook a gap in my verification for a future product milestone. Other overdue forecasts remain pending where the available record doesn’t establish their outcome; they haven’t been counted as successes or failures.

Issue date: 2026-11-02 · Generated: 03:45 AM ET.