<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community: Mir Arshad Ali Talpur</title>
    <description>The latest articles on DEV Community by Mir Arshad Ali Talpur (@mir_arshadalitalpur_1b3).</description>
    <link>https://dev.to/mir_arshadalitalpur_1b3</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F4063668%2F5b31344f-7d58-40dc-881c-6ae41ec788c3.jpeg</url>
      <title>DEV Community: Mir Arshad Ali Talpur</title>
      <link>https://dev.to/mir_arshadalitalpur_1b3</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/mir_arshadalitalpur_1b3"/>
    <language>en</language>
    <item>
      <title>How to Run an AI Agent Incident Response with ZizkaDB: A Runbook for the First 72 Hours</title>
      <dc:creator>Mir Arshad Ali Talpur</dc:creator>
      <pubDate>Thu, 19 Nov 2026 11:33:35 +0000</pubDate>
      <link>https://dev.to/mir_arshadalitalpur_1b3/how-to-run-an-ai-agent-incident-response-with-zizkadb-a-runbook-for-the-first-72-hours-i2</link>
      <guid>https://dev.to/mir_arshadalitalpur_1b3/how-to-run-an-ai-agent-incident-response-with-zizkadb-a-runbook-for-the-first-72-hours-i2</guid>
      <description>&lt;p&gt;An AI agent sends the wrong message to a customer. Or it calls a tool it should not have. Or a component it depends on turns out to be compromised. Someone notices, a channel fills with messages, and a clock you cannot see starts to run.&lt;/p&gt;

&lt;p&gt;For many teams, the first hours of an agent incident are improvised. People ask the same questions in different threads: what did the agent read, what did it do, who else is affected, what do we tell the customer, do we have to tell a regulator. Without a record that can answer those questions, the answers come slowly and with doubt.&lt;/p&gt;

&lt;p&gt;This guide is a runbook for the first 72 hours of an AI agent incident, built around a record that lets you answer fast. It covers what to prepare before an incident, then what to do in hours 0 to 1, 1 to 8, 8 to 24 and 24 to 72, then the longer tail. The audit layer in the examples is ZizkaDB, an open source causal audit database for AI agents, but the runbook works with any tool that gives you causally linked, tamper-evident records.&lt;/p&gt;

&lt;p&gt;A note on scope. This is operational guidance, not legal advice. Whether any reporting duty applies to you, and how deadlines are counted, depends on your product, your role and your jurisdiction, so involve counsel early. ZizkaDB supports record keeping and investigation and does not by itself make any system compliant with any law. Code parameter names are illustrative and should be checked against the SDK reference.&lt;/p&gt;

&lt;p&gt;Why the clocks matter&lt;/p&gt;

&lt;p&gt;Several regimes now put time limits on incident reporting. You may be subject to none, one or several, so the point here is awareness, not a legal checklist.&lt;/p&gt;

&lt;p&gt;EU Cyber Resilience Act. Reporting obligations under Article 14 began to apply on 11 September 2026 to manufacturers of in-scope products with digital elements. According to the European Commission and ENISA, an early warning is due within 24 hours of becoming aware of an actively exploited vulnerability or a severe incident, a fuller notification within 72 hours, and a final report no later than 14 days after a corrective measure is available for an exploited vulnerability, or within one month for a severe incident. Law firm commentary stresses that the clock runs from awareness, not from the moment the issue is fully analysed. Whether your agent product is in scope is a question for counsel.&lt;/p&gt;

&lt;p&gt;EU AI Act, Article 73. For providers of high-risk AI systems, serious incidents must be reported to market surveillance authorities immediately after a causal link, or the reasonable likelihood of one, is established, and in any event not later than 15 days after awareness. Summaries commonly state a 10 day limit where a death is involved and 2 days for widespread infringements or critical infrastructure disruption. The Digital Omnibus on AI moved the application date for stand-alone high-risk obligations to 2 December 2027, and summaries note the Commission's serious incident guidance was still a draft when they were written. Commentators warn that 15 days is a short runway if the first conversation about whether this is our incident does not happen until a week in, and that the way days are counted is a point on which summaries differ.&lt;/p&gt;

&lt;p&gt;GDPR. Where an incident involves a personal data breach, the notification window to the supervisory authority is generally 72 hours from awareness, subject to the conditions in the regulation.&lt;/p&gt;

&lt;p&gt;The practical lesson is the same across all three. The speed of your response depends on how quickly you can establish what happened, who is affected and how bad it is. That is a question about your record.&lt;/p&gt;

&lt;p&gt;Phase 0: prepare before anything goes wrong&lt;/p&gt;

&lt;p&gt;A runbook is only as good as the record behind it. Before an incident, make sure of the following.&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;&lt;p&gt;The record has what you will need. For each agent action, the record should contain the input received, the context retrieved, the model and prompt versions, the tool called with its version, the decision made, the human review if any, the customer or tenant, and the output delivered. Each event links to the event that caused it.&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;External inputs are tagged. Anything from a source you do not control, such as a web page, a partner feed, another agent or a user upload, carries a trust tag. It makes later questions easy: which decisions depended on untrusted input.&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;Tools and components are versioned in the record. If an MCP server, plugin or package is later found to be compromised, you need to know which agent actions called which version.&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;The chain head is stored outside the database. ZizkaDB computes a SHA-256 checksum for each event and chains events per agent, so edits to history are detectable. Store the chain head in a system administrators cannot edit, and verify on a schedule. Without that, an investigator, a customer or a regulator has less reason to trust the record.&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;Read-only evidence access is ready. Have a process to grant an auditor or customer a read-only, expiring key.&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;Roles and a severity scale exist. Name an incident commander, a scribe, a communications lead and a legal contact. Agree what counts as low, medium and high severity, and who can declare an incident.&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;You have timed a drill. Pick a past case and measure how long it takes someone who did not work on it to answer four questions from the record alone: what did the agent read, what did it decide, who reviewed it, and which other cases are affected.&lt;/p&gt;&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Phase 1: hour 0 to 1, declare, contain and freeze evidence&lt;/p&gt;

&lt;p&gt;The first hour has three jobs. Do them in this order.&lt;/p&gt;

&lt;p&gt;Declare the incident and start the log&lt;/p&gt;

&lt;p&gt;Create an incident event and keep a running timeline as events linked to it. A recorded timeline matters later, because the time you became aware may be a regulatory question.&lt;/p&gt;

&lt;p&gt;python&lt;br&gt;
inc = await db.log(agent="incident-response", event="incident_declared",&lt;br&gt;
    data={"id": "INC-2026-114", "reported_by": "support-lead",&lt;br&gt;
          "first_signal": "customer complaint about refund email",&lt;br&gt;
          "aware_at": "2026-11-19T09:42:00Z", "severity": "high"})&lt;/p&gt;

&lt;p&gt;Record who noticed what and when. The moment of awareness may be disputed, so write down how you determined it.&lt;/p&gt;

&lt;p&gt;Contain&lt;/p&gt;

&lt;p&gt;Stop the damage first. Typical containment actions are pausing the agent, disabling a tool, revoking a credential, switching to a safe fallback or moving the workflow to human handling. Log each action as an event linked to the incident, with who did it and why.&lt;/p&gt;

&lt;p&gt;python&lt;br&gt;
await db.log(agent="incident-response", event="containment_action",&lt;br&gt;
    data={"action": "disable_tool", "tool": "issue_refund", "by": "ops-lead"},&lt;br&gt;
    parent_id=inc.id)&lt;/p&gt;

&lt;p&gt;Containment decisions made under pressure are the ones people later question. The log lets you show the reasoning.&lt;/p&gt;

&lt;p&gt;Freeze the evidence&lt;/p&gt;

&lt;p&gt;Before anyone investigates, preserve the record as it stands. Export the relevant events, verify the chain, and note the chain head.&lt;/p&gt;

&lt;p&gt;python&lt;br&gt;
check = await db.verify_chain(agent="support-agent")&lt;br&gt;
export = await db.export_events(agent="support-agent",&lt;br&gt;
    since="2026-11-12", until="2026-11-19")&lt;/p&gt;

&lt;p&gt;await db.log(agent="incident-response", event="evidence_frozen",&lt;br&gt;
    data={"chain_ok": check.ok, "chain_head": check.head,&lt;br&gt;
          "events_exported": len(export), "by": "scribe"},&lt;br&gt;
    parent_id=inc.id)&lt;/p&gt;

&lt;p&gt;Store the export and the chain head somewhere separate. Do not alter, delete or rewrite anything in the affected period. Avoiding changes to evidence is part of any later investigation, and it protects you from the suspicion that you edited history.&lt;/p&gt;

&lt;p&gt;Phase 2: hours 1 to 8, reconstruct what happened&lt;/p&gt;

&lt;p&gt;This is where causal lineage pays for itself. You are answering four questions, in order.&lt;/p&gt;

&lt;p&gt;Question 1: what did the agent do, and why?&lt;/p&gt;

&lt;p&gt;Start from the bad outcome and walk backwards. If the problem is a wrong email, find the event for the email and run lineage on it.&lt;/p&gt;

&lt;p&gt;python&lt;br&gt;
(await db.why(bad_email.id)).print()&lt;/p&gt;

&lt;p&gt;Read the chain from the output back through the decision, the retrieved context and the original request. Note the model and prompt versions on the decision, and any human review in between. Often this alone reveals the cause: an outdated document retrieved, a misread input, a tool that returned something unexpected.&lt;/p&gt;

&lt;p&gt;Question 2: where did the bad input come from?&lt;/p&gt;

&lt;p&gt;If the chain leads to an external input, look at its trust tag, source and author. If it leads to a tool, look at the tool and version. If it leads to a memory write, find the event that wrote it and the input behind that. Keep going until you reach the first event that does not depend on another.&lt;/p&gt;

&lt;p&gt;Question 3: who else is affected?&lt;/p&gt;

&lt;p&gt;This is the question that decides your severity, your customer communications and your reporting duties. Use the impact route from the root cause event to list every downstream event that depended on it.&lt;/p&gt;

&lt;p&gt;python&lt;br&gt;
affected = await db.impact(root_cause.id)&lt;br&gt;
by_customer = group_by(affected, key="customer")&lt;/p&gt;

&lt;p&gt;The route is also available over HTTP at GET /v1/events/{event_id}/impact. Turn the result into a table: affected cases, customers or tenants, what each received, whether a human reviewed it, and whether personal data was involved. This list is the most valuable artifact of the first eight hours.&lt;/p&gt;

&lt;p&gt;Question 4: is it still happening?&lt;/p&gt;

&lt;p&gt;Check recent events for the same pattern. If a poisoned document is still in retrieval, or a compromised tool version is still deployed, containment is incomplete. If it is a memory problem, write a corrected memory that supersedes the bad one, so the agent stops retrieving it while the history stays intact for the investigation.&lt;/p&gt;

&lt;p&gt;Replay the session when the chain is not enough&lt;/p&gt;

&lt;p&gt;For complicated cases, replay the full session in order: every read, decision and tool call with timestamps. Look for things the lineage alone does not show, such as a retry loop, an unusual sequence or a long gap.&lt;/p&gt;

&lt;p&gt;Throughout this phase, the scribe records findings as events linked to the incident. Include dead ends, because they matter when someone later asks why you ruled something out.&lt;/p&gt;

&lt;p&gt;Phase 3: hours 8 to 24, assess, classify and decide on reporting&lt;/p&gt;

&lt;p&gt;By now you should know what happened and roughly how many were affected. The next job is to decide what it means.&lt;/p&gt;

&lt;p&gt;Establish the causal link. Several regimes turn on whether the incident was caused by, or reasonably likely to be caused by, the system. The lineage is your evidence. Write down the causal chain in plain language.&lt;/p&gt;

&lt;p&gt;Assess severity and impact. Use the affected-cases table. Consider harm to people, data involved, financial impact, effect on critical services, and whether the problem is ongoing.&lt;/p&gt;

&lt;p&gt;Check data protection. If personal data was exposed, altered or lost, bring in your data protection lead. The affected-cases table shows which individuals and what data.&lt;/p&gt;

&lt;p&gt;Classify and decide with counsel. Whether a reporting duty applies, to whom, and by when, is a legal judgment. Give counsel the incident timeline, the causal chain and the impact list. Record the classification decision and its rationale as an event, including any dissenting views, so that the reasoning is documented.&lt;/p&gt;

&lt;p&gt;python&lt;br&gt;
await db.log(agent="incident-response", event="classification",&lt;br&gt;
    data={"severity": "high", "causal_link": "established",&lt;br&gt;
          "personal_data": True, "reportable": "under review with counsel",&lt;br&gt;
          "affected_cases": 37, "decided_by": "incident-commander"},&lt;br&gt;
    parent_id=inc.id)&lt;/p&gt;

&lt;p&gt;Prepare an early notification if one is needed. A first report can be short. It generally says what you know, what you do not yet know, and what you have done. Do not wait for a complete analysis if a deadline requires an early warning, and say clearly what remains under investigation. Initial incomplete reports followed by fuller ones are a feature of several regimes, so check what applies to you.&lt;/p&gt;

&lt;p&gt;Phase 4: hours 24 to 72, notify, communicate and remediate&lt;br&gt;
Notify&lt;/p&gt;

&lt;p&gt;If counsel confirms that a report is due, build it from the record. The record can supply the product and version details, the timeline, the causal chain, the affected population, the containment actions and the data involved. Review it for accuracy before sending, because a report built from a verified record is easier to defend than one built from memory.&lt;/p&gt;

&lt;p&gt;Tell customers precisely&lt;/p&gt;

&lt;p&gt;Customers want to know whether they are affected, what happened to them and what you are doing. The affected-cases table lets you tell each customer exactly what applies to them, instead of a vague notice to everyone. Precision builds trust. For customers who want to verify, offer a read-only, expiring evidence key scoped to their own record.&lt;/p&gt;

&lt;p&gt;Fix and verify the fix&lt;/p&gt;

&lt;p&gt;Remediate the cause: correct the retrieval rule, replace the compromised tool version, update the prompt, supersede the bad memory, or add a guard. Then test the fix before you restore full service. Replay the affected cases and a sample of normal ones against the fixed configuration in shadow mode, and compare. That is the same method used for safe model and prompt upgrades. Log the fix and the verification as events linked to the incident.&lt;/p&gt;

&lt;p&gt;Restore carefully&lt;/p&gt;

&lt;p&gt;Return service in stages, starting with a small share of traffic and watching the signals that mattered in the incident. Set rollback criteria in advance.&lt;/p&gt;

&lt;p&gt;Phase 5: day 3 and beyond, final report and learning&lt;/p&gt;

&lt;p&gt;Final report. Where a final report is required, the deadlines vary by regime and by the type of event, so confirm with counsel. The record helps again: root cause, timeline, impact, corrective measures and what you are changing to prevent recurrence.&lt;/p&gt;

&lt;p&gt;Post-incident review. Hold a blameless review within a week or two. Use the recorded timeline to see where time was lost. Ask what the record could not answer that it should have, and fix the instrumentation. Add the missing fields, the missing trust tags or the missing versions.&lt;/p&gt;

&lt;p&gt;Update your controls. Adjust baselines so that drift checks cover the signal that would have caught this earlier. Update the runbook, the severity scale and the drill.&lt;/p&gt;

&lt;p&gt;Keep the evidence. Retain the incident record, the export and the chain verification results according to your retention policy and legal advice, with the chain head stored independently.&lt;/p&gt;

&lt;p&gt;Two illustrative scenarios&lt;/p&gt;

&lt;p&gt;These scenarios are composites, not real customers.&lt;/p&gt;

&lt;p&gt;Scenario 1: a stale document drives wrong refunds&lt;/p&gt;

&lt;p&gt;A retail support agent starts approving refunds that policy does not allow. A customer complains, and the support lead declares an incident. Containment is quick: the refund tool is disabled. Lineage on one of the wrong approvals shows that the agent retrieved an outdated policy document, because a newer version had not been indexed. The impact route lists 37 refunds that descended from that retrieval. Only some were reviewed by a human, and the review events show reviewers spent seconds on them. The team contacts each affected customer with specifics, corrects the index, supersedes the stale memory, replays the 37 cases against the corrected setup and restores the tool in stages. The review also leads to a change in how reviewers are shown the policy version. Because the record could answer the four questions within hours, the team had a clear picture before any reporting deadline became a concern.&lt;/p&gt;

&lt;p&gt;Scenario 2: a compromised tool version&lt;/p&gt;

&lt;p&gt;An operations agent calls an external tool through an MCP server. A public advisory reports that one version of that server was compromised. The security lead declares an incident. Because the record logs the tool and version on every call, a query lists every action that used the affected version, the targets, the time window and the decisions behind them. The team revokes credentials the tool could access, rolls back to a safe version and reviews each affected action. Without version logging, they would have had to assume every call was affected. With it, they can say precisely which were, which is the difference between a broad panic and a bounded incident.&lt;/p&gt;

&lt;p&gt;Common mistakes&lt;br&gt;
Investigating before freezing evidence. Preserve the record first and note the chain head.&lt;br&gt;
No record of awareness. The time you became aware may be a legal question. Write it down and how you determined it.&lt;br&gt;
Skipping containment because the cause is unclear. Contain first, understand second.&lt;br&gt;
Vague customer messages. Use the affected-cases table to be specific.&lt;br&gt;
Letting the record be edited. If the chain head is stored in the same place as the chain, the integrity claim is weak.&lt;br&gt;
Treating the legal question as an afterthought. Involve counsel in the first hours, not the last.&lt;br&gt;
Not logging versions. Without model, prompt and tool versions you cannot scope the problem.&lt;br&gt;
Overclaiming in the report. Say what you know, what you do not know and what you are doing.&lt;br&gt;
A drill you can run this week&lt;br&gt;
Pick a past case and a colleague who did not work on it.&lt;br&gt;
Give them only access to the record and start a clock.&lt;br&gt;
Ask them to declare a mock incident, freeze evidence, run the lineage, list the affected cases and draft a one page summary.&lt;br&gt;
Note how long each step took and where the record failed to answer.&lt;br&gt;
Fix the gaps, such as missing trust tags or versions, and repeat in a month.&lt;/p&gt;

&lt;p&gt;A team that can complete this drill in an afternoon is far better placed than one meeting the problem for the first time during a real incident.&lt;/p&gt;

&lt;p&gt;Limits to remember&lt;/p&gt;

&lt;p&gt;ZizkaDB records, links, measures and shows that the record is unchanged. It does not detect incidents, contain them, decide whether you must report, or write your regulatory filings. The record can be incomplete if instrumentation had gaps, and lineage shows what the agent saw and did, not necessarily why a model reasoned as it did. The open source edition records one agent per install, so multi-agent and multi-tenant investigations use the Cloud edition for fleets and agent to agent recording. Confirm the specific features you rely on, such as verify_chain, export, the impact route and read-only keys, against the current documentation, and take legal advice on your reporting duties.&lt;/p&gt;

&lt;p&gt;Get started&lt;/p&gt;

&lt;p&gt;Pick one agent. Make sure the record includes inputs, versions, trust tags and human reviews, store the chain head outside the database, and run the drill above. You will find the gaps in an afternoon, which is far better than finding them at 3 a.m. with a clock running.&lt;/p&gt;

&lt;p&gt;ZizkaDB runs self hosted in a single Docker container, with a managed Cloud edition at db.zizka.ai for multi-agent setups.&lt;/p&gt;

&lt;p&gt;Corrections: if you represent a party named here and believe a statement is inaccurate, contact us and we will review it promptly.&lt;/p&gt;

&lt;p&gt;Sources: European Commission, Cyber Resilience Act reporting obligations; ENISA CRA Single Reporting Platform factsheet (July 2026); Cloud Security Alliance research note on CRA Article 14 (October 2026); law firm commentary from CMS, Pennington and Addleshaw Goddard on CRA reporting; European Commission AI Act Service Desk, Article 73; practitioner summaries of Article 73 timelines, including CIO.com and a developer playbook; legal summaries of the Digital Omnibus on AI; ZizkaDB documentation.&lt;/p&gt;

</description>
      <category>agents</category>
      <category>ai</category>
      <category>security</category>
      <category>tutorial</category>
    </item>
    <item>
      <title>Why Open Source Still Wins Trust in the AI Era, Even as Attacks Go Automated</title>
      <dc:creator>Mir Arshad Ali Talpur</dc:creator>
      <pubDate>Wed, 18 Nov 2026 13:31:07 +0000</pubDate>
      <link>https://dev.to/mir_arshadalitalpur_1b3/why-open-source-still-wins-trust-in-the-ai-era-even-as-attacks-go-automated-1gh9</link>
      <guid>https://dev.to/mir_arshadalitalpur_1b3/why-open-source-still-wins-trust-in-the-ai-era-even-as-attacks-go-automated-1gh9</guid>
      <description>&lt;p&gt;There is a tempting argument going around. Attackers now use AI to find and exploit weaknesses at machine speed, public code is easy to study, so the safe move is to close the code and hide behind the door.&lt;/p&gt;

&lt;p&gt;We think that argument is wrong, and this article explains why. Our view is simple: in the AI era, the vendors who keep their code open and back it with verifiable evidence will win more trust than the vendors who ask buyers to take their word. Automated attacks are real, and the recent evidence is sobering. But the evidence points at weak pipelines, overloaded maintainers and unverified dependencies, not at openness itself. The answer to those problems is more verification, not less visibility.&lt;/p&gt;

&lt;p&gt;This is an advocacy piece, and we say so. We build ZizkaDB, an open source causal audit database for AI agents, and we chose open source deliberately. We will make the case for it with recent facts, give the strongest counterpoint fairly, and finish with what it means for ZizkaDB.&lt;/p&gt;

&lt;p&gt;A note on sources. The facts below come from public reports, security research notes, legal commentary and surveys published in 2026. Some are from vendors or blogs with commercial interests, and we flag that where it matters. Figures differ between sources, so we attribute them or give approximate values. Nothing here is legal advice.&lt;/p&gt;

&lt;p&gt;The threat is real, and we should look at it squarely&lt;/p&gt;

&lt;p&gt;Supply chain attacks now propagate by themselves. A Cloud Security Alliance research note describes a self-propagating npm worm, dubbed Mini Shai-Hulud, attributed to a group called TeamPCP. According to the note, a wave on 11 May 2026 published hundreds of malicious package versions across well over a hundred npm packages, plus two on PyPI, in under six hours, and reached AI developer ecosystems including TanStack, Mistral AI, UiPath, OpenSearch and Guardrails AI. Two versions of the note give slightly different counts, such as 404 malicious versions across 172 npm packages in one and 373 versions across 169 packages in another, so treat the exact numbers as approximate.&lt;/p&gt;

&lt;p&gt;The note reports that the worm produced packages carrying valid SLSA Build Level 3 provenance attestations, by hijacking the legitimate release pipeline instead of stealing credentials and publishing from outside. A control many teams rely on said the package was fine. A separate vendor analysis reports that the worm's source was published on 12 May and that derivative campaigns followed within weeks.&lt;/p&gt;

&lt;p&gt;Discovery is being industrialised, and maintainers feel it first. Help Net Security reported in May 2026 that AI-powered industrialisation of vulnerability discovery is a much bigger problem for open source projects than for big organisations, because open source relies on volunteer maintainers with limited time. Secondary accounts report that curl ended its paid bug bounty on 31 January 2026, that its confirmed-vulnerability rate fell from roughly 15 percent to under 5 percent as low-quality AI-generated reports flooded in, and that it paused vulnerability reports from 1 July to 3 August. Other reports say the Internet Bug Bounty paused new submissions in March, and that Linus Torvalds said in May that the kernel's security list had become almost entirely unmanageable because of duplicate AI-generated reports. Several of these come from blogs summarising primary statements, so check the projects' own announcements before quoting them.&lt;/p&gt;

&lt;p&gt;These are not small problems. They are the honest cost side of open source in 2026, and the rest of this article does not wave them away.&lt;/p&gt;

&lt;p&gt;Why the threat does not undercut the case for open source&lt;/p&gt;

&lt;p&gt;First, closing the code does not remove the exposure. Black Duck's 2026 Open Source Security and Risk Analysis, covering 947 audited codebases, found that 97 percent of commercial codebases contain open source components, according to a commentary on the report, and that open source vulnerabilities per codebase doubled to 581. A closed product built on open components inherits every one of those risks. The worm above hit packages that closed and open products alike depend on. Keeping your own code private does not protect you from a poisoned dependency. It only prevents your customers from seeing what you depend on.&lt;/p&gt;

&lt;p&gt;Second, the attacks target pipelines and people, not openness. The worm's novelty was hijacking a legitimate release pipeline. The curl story is about maintainer time. Neither is a flaw that disappears when the repository is made private. A closed vendor with a weak build pipeline and a small security team has the same problem, plus no outside reviewers to notice. The principle that security should not rest on secrecy is old and widely held. We offer it as an argument, not as data, but the recent evidence is consistent with it.&lt;/p&gt;

&lt;p&gt;Third, open code lets buyers verify things that closed vendors can only assert. With open source, a buyer can read the code, build it, check what is running against what was published, self host it, and keep the data inside their own environment. When an attack like the worm hits, an open project can be inspected, its dependencies listed and its fix reviewed in public. With a closed product, the buyer waits for a statement.&lt;/p&gt;

&lt;p&gt;Fourth, buyers are already telling us what they value. A Linux Foundation survey of 316 AI professionals found that 94 percent of organisations use generative AI, that about 41 percent of their AI code infrastructure is open source on average, and that 52 percent prioritise transparency and source code access when choosing AI solutions. A Red Hat survey of UK organisations on AI sovereignty found that four in five said open source offers greater control over how AI is built and where it runs, and 87 percent named transparency and easier auditability as the most valuable benefit for building trust in AI. These are survey results with their own sponsors and sample limits, but they point the same way.&lt;/p&gt;

&lt;p&gt;Fifth, trust is the commercial advantage. The Linux Foundation's State of Commercial Open Source 2026 report, based on a survey of 225 founders and enterprise leaders, identifies community trust as the top competitive advantage for commercial open source companies, and enterprise sales capability as the main scaling bottleneck. The model works: win trust in the open, then serve enterprises that need it.&lt;/p&gt;

&lt;p&gt;Sixth, regulation rewards traceable components. The EU Cyber Resilience Act's reporting obligations for manufacturers have applied since 11 September 2026, covering actively exploited vulnerabilities and severe incidents, including for products already on the market. Non-commercial open source is outside the Act, but commercial use of open source is not, so vendors must know what is inside their products. Open source stewards, who systematically support open source intended for commercial use, have lighter obligations from 11 December 2027. Buyers will ask vendors how components are tracked, and open projects with public dependency lists are better placed to answer.&lt;/p&gt;

&lt;p&gt;The fair counterpoint&lt;/p&gt;

&lt;p&gt;A fair reading also has to include the arguments on the other side. Critics say that open code is only as safe as the attention it gets, and in 2026 that attention is scarce. Most projects have very few maintainers, and the curl and kernel stories show them under strain. Visibility is not verification: anyone can read the code, but few buyers do, and the worm showed that even strong provenance controls can be subverted. Some security teams will also argue that for the highest assurance needs, a closed system under a vendor's contractual liability is simpler to govern.&lt;/p&gt;

&lt;p&gt;These points deserve a serious response, and ours is this. If visibility alone is not enough, the answer is to add verification and to fund the work, not to close the door. Which leads to what open source vendors owe their buyers.&lt;/p&gt;

&lt;p&gt;What open source vendors must do to earn the trust&lt;/p&gt;

&lt;p&gt;Being open is the start, not the finish. Five commitments turn openness into trust.&lt;/p&gt;

&lt;p&gt;Maintain a visible security process. A published policy, a way to report vulnerabilities, and a record of how fast fixes ship.&lt;br&gt;
Harden the release pipeline. Treat the pipeline as part of the attack surface, since provenance alone can be subverted.&lt;br&gt;
Track dependencies and publish what is inside. Keep an inventory, update promptly and be ready to say which versions are affected when a component is compromised.&lt;br&gt;
Support self hosting and verification. Let customers build and check what runs against what was published, and keep their data in their own environment.&lt;br&gt;
Give customers evidence they control. When something goes wrong, they should be able to reconstruct what happened from records they own, without waiting for the vendor.&lt;/p&gt;

&lt;p&gt;Commercial open source companies also have a duty that individual hobby projects cannot meet: fund the maintenance. If a company profits from open code, it should pay for the security work that sustains it.&lt;/p&gt;

&lt;p&gt;Where ZizkaDB fits&lt;/p&gt;

&lt;p&gt;We chose open source for ZizkaDB for the reasons above, and we think a database whose job is to provide audit evidence should itself be open to audit.&lt;/p&gt;

&lt;p&gt;Open code, inspectable by buyers. The ZizkaDB core is licensed AGPL-3.0 and the MCP server is MIT licensed. Teams can read the code, self host it in a single Docker container, and keep the audit record inside their own environment, which matters for sovereignty and data residency.&lt;/p&gt;

&lt;p&gt;Verification, not just visibility. ZizkaDB records each agent step as an event, links it to the event that caused it, and protects the record with SHA-256 checksums and a per-agent hash chain, so edits to history are detectable. If you store the chain head outside the database, you can check on your own schedule that nobody rewrote the record. That is the fifth commitment above: evidence you control.&lt;/p&gt;

&lt;p&gt;Evidence for when prevention fails. The threat evidence says compromises will happen. When one does, the useful questions are what ran, what it read and what it affected. If you log the tools, packages and MCP servers your agents call, with versions, and link decisions to the inputs behind them, the lineage and the impact route help scope which agent actions depended on a component later found to be bad. An illustrative record, with parameter names to be checked against the SDK reference:&lt;/p&gt;

&lt;p&gt;python&lt;br&gt;
call = await db.log(agent="ops-agent", event="tool_call",&lt;br&gt;
    data={"tool": "mcp-server-x", "version": "1.4.2", "target": "ticket-881"},&lt;br&gt;
    parent_id=decision.id)&lt;/p&gt;

&lt;p&gt;A model that funds the work. Open source projects need sustainable funding. ZizkaDB offers a managed Cloud edition at db.zizka.ai for teams that want fleets, multi-agent and agent to agent recording, and that is how we aim to keep the open core maintained.&lt;/p&gt;

&lt;p&gt;Our own posture, stated carefully. The ZizkaDB MCP server is listed on AddonAudit, which reports passing automated checks and a metadata score of 100 for public metadata. That page describes itself as an automated smoke test and not a security guarantee, and we say the same. We encourage buyers to run their own review of the code. That is the point of keeping it open.&lt;/p&gt;

&lt;p&gt;Limits. ZizkaDB records, links and shows that the record is unchanged. It does not prevent supply chain attacks, detect malicious packages, or judge whether an output is correct, and it does not replace dependency scanning, signing, sandboxing or least privilege. The open source edition records one agent per install, and fleets and agent to agent recording use the Cloud edition. ZizkaDB supports record keeping and investigation and does not by itself make any system compliant with the EU AI Act, the Cyber Resilience Act or any other law. Confirm the specific features you rely on against the current documentation.&lt;/p&gt;

&lt;p&gt;The takeaway&lt;/p&gt;

&lt;p&gt;Automation has made attacks on shared code cheaper, and it has made buyers more demanding about what they run. Closing the code answers the first by weakening the second. We think the better answer is to keep the code open, harden the process, fund the maintainers and give buyers evidence they can check for themselves. Openness earns the first meeting. Verifiable evidence closes the deal.&lt;/p&gt;

&lt;p&gt;If you run AI agents, start small. Pick one agent, log its tool calls with versions and the events that caused them, and verify the chain on a schedule. ZizkaDB runs self hosted in a single Docker container, with a managed Cloud edition at db.zizka.ai for multi-agent setups.&lt;/p&gt;

&lt;p&gt;Corrections: if you represent a party named here and believe a statement is inaccurate, contact us and we will review it promptly.&lt;/p&gt;

&lt;p&gt;Sources: Cloud Security Alliance research notes on Mini Shai-Hulud (May 2026); TuxCare analysis of 2026 supply chain attacks; Help Net Security, AI is drowning software maintainers in junk security reports (May 2026); Pinggy, curl's Summer of Bliss (July 2026); Falcao, AI bug reports and open source (May 2026); Resilient Cyber, Vulnpocalypse (2026 Black Duck OSSRA commentary); Linux Foundation survey of AI professionals, via CO/AI; Linux Foundation and Serena, The State of Commercial Open Source 2026; Red Hat UK AI sovereignty survey, via IT Brief UK; legal commentary on the EU Cyber Resilience Act reporting obligations from Goodwin, Travers Smith, Matheson and HLC (September 2026); ZizkaDB documentation.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>opensource</category>
      <category>security</category>
      <category>architecture</category>
    </item>
    <item>
      <title>How to Upgrade Your LLM Without Breaking Production: A Replay Testing Guide with ZizkaDB</title>
      <dc:creator>Mir Arshad Ali Talpur</dc:creator>
      <pubDate>Tue, 17 Nov 2026 09:01:07 +0000</pubDate>
      <link>https://dev.to/mir_arshadalitalpur_1b3/how-to-upgrade-your-llm-without-breaking-production-a-replay-testing-guide-with-zizkadb-4e9l</link>
      <guid>https://dev.to/mir_arshadalitalpur_1b3/how-to-upgrade-your-llm-without-breaking-production-a-replay-testing-guide-with-zizkadb-4e9l</guid>
      <description>&lt;p&gt;Sooner or later every team running AI agents in production faces the same decision. The model provider is retiring the version you use. A cheaper model has appeared that might do the job. Latency is too high, or a customer wants their data processed in a different region. Someone edits the prompt to fix one complaint. In each case the question is identical: will the agent still behave the way our customers rely on?&lt;/p&gt;

&lt;p&gt;Most teams answer it with a handful of manual tests and a hopeful release. Then, a week later, approval rates shift, reviewers start correcting a new kind of mistake, and nobody can say whether the change came from the upgrade or from something else.&lt;/p&gt;

&lt;p&gt;This guide shows a better way, using something you already have if you record your agents properly: a history of real cases. You will turn recorded production history into a replay test, run a candidate model or prompt in shadow mode against it, compare the results with evidence, release in stages, and keep a sign-off record that you can show a customer or auditor. The audit layer in the examples is ZizkaDB, an open source causal audit database for AI agents, but the method applies wherever you have causally linked history.&lt;/p&gt;

&lt;p&gt;A note on scope. ZizkaDB is not an evaluation framework and does not judge whether an answer is good. It records and links what happened, so you can build a trustworthy test set and compare runs. Code parameter names are illustrative and should be checked against the SDK reference. Nothing here is legal advice, and ZizkaDB does not by itself make any system compliant with the EU AI Act or any other law.&lt;/p&gt;

&lt;p&gt;Why upgrades are riskier than they look&lt;/p&gt;

&lt;p&gt;Agents built on language models are probabilistic. Two versions of a model can both be good and still behave differently on the cases your customers care about. A new version may be more verbose, more cautious, quicker to call a tool, or slightly different in how it follows your formatting rules. None of this throws an error. It shows up as agent drift: a slow shift in outcomes that no alert catches.&lt;/p&gt;

&lt;p&gt;Three business realities make this a real problem for vertical AI companies and any enterprise running agents.&lt;/p&gt;

&lt;p&gt;Forced upgrades are routine. Model versions are retired on the provider's schedule, not yours. If your only test is a few examples someone remembers, you are gambling on a deadline.&lt;/p&gt;

&lt;p&gt;Cost pressure invites change. A cheaper or faster model can cut your bill sharply, and the temptation to switch is strong. Without a way to show that quality held, you cannot make the switch with confidence, and you cannot justify it to a customer who asks.&lt;/p&gt;

&lt;p&gt;Customers care about change. Enterprise buyers ask how you manage changes to the AI in your product, and they notice when behaviour changes without notice. A documented, evidence-based change process is part of what they buy.&lt;/p&gt;

&lt;p&gt;The common failure is not a dramatic outage. It is a quiet degradation on a slice of cases, found by a customer instead of by you.&lt;/p&gt;

&lt;p&gt;The idea: replay real cases against the candidate&lt;/p&gt;

&lt;p&gt;The core idea is simple. If you have recorded real cases, with their inputs, retrieved context and outcomes, you can run the same inputs through a candidate configuration and compare. You are not guessing what customers send, because you have what they sent.&lt;/p&gt;

&lt;p&gt;For this to work, your record needs a few things:&lt;/p&gt;

&lt;p&gt;The inputs the agent received, with sensitive values redacted where appropriate.&lt;br&gt;
The context it retrieved, so the candidate can be given the same material.&lt;br&gt;
The output and decision of the production version.&lt;br&gt;
The versions: model, prompt and tool configuration on each call.&lt;br&gt;
The human outcome: whether a reviewer accepted, edited or rejected the result, and what they changed.&lt;br&gt;
The customer and task type, so you can sample fairly.&lt;/p&gt;

&lt;p&gt;If you log events with causal links, as described in our other guides, you already have this. If not, start there: add model and prompt versions and human review events to your instrumentation first, because replay is only as good as the record.&lt;/p&gt;

&lt;p&gt;Step 1: build a test set from production history&lt;/p&gt;

&lt;p&gt;Do not replay everything. Build a deliberate sample that reflects the risks.&lt;/p&gt;

&lt;p&gt;Stratify. Take cases across customers, task types and time periods, so that one busy customer does not dominate. Include recent cases, since they reflect current behaviour.&lt;/p&gt;

&lt;p&gt;Include the hard ones. Add cases where a human reviewer corrected or rejected the agent. These are your most valuable tests, because they show where the production version already struggles, and a candidate that fixes them is a real improvement. Add cases that triggered errors, long inputs and unusual formats.&lt;/p&gt;

&lt;p&gt;Include the boring ones. The bulk of the set should be ordinary cases the agent handles well. A candidate that fails on these is not ready.&lt;/p&gt;

&lt;p&gt;Keep it sensitive-data safe. Redact before storage and before replay. Before you send customer data to any new model provider, check your contracts and data processing terms, because a different provider may be a new subprocessor that customers must be told about. This is easy to forget and expensive to get wrong.&lt;/p&gt;

&lt;p&gt;You can pull the set with ZizkaDB's export and iteration functions. An illustrative sketch:&lt;/p&gt;

&lt;p&gt;python&lt;br&gt;
cases = []&lt;br&gt;
async for ev in db.iter_events(agent="claims-agent", event="decision",&lt;br&gt;
                               since="2026-09-01"):&lt;br&gt;
    cases.append(ev)&lt;/p&gt;

&lt;h1&gt;
  
  
  pair each decision with its human review and the retrieved context
&lt;/h1&gt;

&lt;p&gt;test_set = build_test_set(cases, include_corrected=True, per_customer_cap=50)&lt;/p&gt;

&lt;p&gt;Freeze the test set once built. A moving test set makes comparisons meaningless.&lt;/p&gt;

&lt;p&gt;Step 2: run the candidate in shadow mode&lt;/p&gt;

&lt;p&gt;Shadow mode means the candidate processes the same inputs, but its output never reaches a customer. You record what it would have done and compare.&lt;/p&gt;

&lt;p&gt;Log the shadow run under a separate agent name, and link each shadow decision back to the production decision it mirrors. That link is the key to everything that follows. Illustrative code:&lt;/p&gt;

&lt;p&gt;python&lt;br&gt;
for case in test_set:&lt;br&gt;
    out = await run_candidate(case.input, case.context,&lt;br&gt;
                              model="candidate-model", prompt_v="v15")&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight plaintext"&gt;&lt;code&gt;await db.log(agent="claims-agent-shadow", event="decision",
    data={"outcome": out.outcome, "reason": out.reason,
          "model": "candidate-model", "prompt_v": "v15",
          "tokens": out.tokens, "latency_ms": out.latency_ms},
    parent_id=case.production_decision_id)
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;

&lt;p&gt;Because the shadow decision points to the production one, you can walk from either side to the other. You can also use batching and idempotency keys when logging many shadow results, so that a retry does not duplicate events.&lt;/p&gt;

&lt;p&gt;Two practical points. First, run the candidate more than once on a sample if outputs vary, because a single run of a probabilistic model can mislead. Second, keep the shadow agent's record separate from production metrics, so shadow runs do not pollute your drift baselines for the live agent.&lt;/p&gt;

&lt;p&gt;Step 3: compare with evidence, not impressions&lt;/p&gt;

&lt;p&gt;Now you have paired results. Compare them on what matters to your business, and write down the criteria before you look at the numbers, so you do not shape them to fit the result.&lt;/p&gt;

&lt;p&gt;Agreement. How often does the candidate reach the same outcome as production? High agreement is reassuring, but the disagreements are where the information is.&lt;/p&gt;

&lt;p&gt;Performance on the corrected cases. Among cases where a human reviewer overrode production, how often does the candidate land on the human's answer? This is the closest thing to ground truth in your data, and it tells you whether the candidate is better, equal or worse where it counts.&lt;/p&gt;

&lt;p&gt;Regressions. Among cases production got right and the human accepted, how often does the candidate differ? Each is a potential regression to review.&lt;/p&gt;

&lt;p&gt;Cost. Tokens and spend per case, from the recorded usage. This is where a cheaper model earns its keep, but only if quality holds.&lt;/p&gt;

&lt;p&gt;Speed. Latency per case.&lt;/p&gt;

&lt;p&gt;Behaviour mix. Tool calls per case, refusal rate, output length, and the share of cases where the candidate cites its sources. A model that suddenly calls twice as many tools may be fine, or may be wasting money or taking risks.&lt;/p&gt;

&lt;p&gt;By segment. Break results down by customer, task type and language. An average can hide a slice where the candidate fails badly.&lt;/p&gt;

&lt;p&gt;ZizkaDB's baseline() can help here by comparing the shadow agent's behaviour against the production agent's reference period on the metrics you choose. It does not decide whether a difference is good. You do.&lt;/p&gt;

&lt;p&gt;Step 4: review disagreements with lineage&lt;/p&gt;

&lt;p&gt;Averages tell you how much differs. Lineage tells you why. For each meaningful disagreement, open both sides and read the chains.&lt;/p&gt;

&lt;p&gt;python&lt;br&gt;
(await db.why(shadow_decision.id)).print()&lt;br&gt;
(await db.why(production_decision.id)).print()&lt;/p&gt;

&lt;p&gt;Look for patterns. Did the candidate ignore a retrieved rule? Did it weigh a document differently? Did it fail on a particular input format? Group disagreements into categories and count them. Often the result is not accept or reject but fix the prompt for this category, then rerun. Because the shadow run is recorded with its prompt version, you can compare version 15 against version 16 the same way, and the history of your experiments becomes part of your record.&lt;/p&gt;

&lt;p&gt;A human review of a sample of disagreements is worthwhile. Have a domain expert, not only an engineer, look at them. Record their verdicts as events linked to the cases, so that your conclusions rest on documented judgments.&lt;/p&gt;

&lt;p&gt;Step 5: release in stages and watch for drift&lt;/p&gt;

&lt;p&gt;Passing the replay test does not guarantee success in production, so release gradually.&lt;/p&gt;

&lt;p&gt;Canary. Route a small share of live traffic, by customer or by case, to the candidate. Record the model and prompt version on every call, so that you can separate canary and baseline in your measurements.&lt;/p&gt;

&lt;p&gt;Watch the signals. Compare approval rates, human edit rates, review time, error rates, cost and latency between canary and control. Watch the share of reviewer edits in particular, because a rise means humans are fixing more mistakes.&lt;/p&gt;

&lt;p&gt;Set rollback criteria in advance. Decide before the canary what result triggers rollback, for example a rise in reviewer overrides beyond a threshold, or any case in a critical category going wrong. Having the rule written down removes the temptation to rationalise.&lt;/p&gt;

&lt;p&gt;Expand. If the canary holds, widen it in steps, and keep measuring. When the change is complete, set a new baseline period for the new version so that future drift checks compare against it.&lt;/p&gt;

&lt;p&gt;If something does go wrong, ZizkaDB's time travel features can help you see the agent's state as of a given moment from logged state events, and the impact route can list the cases that descended from a particular input, which helps you scope who was affected and tell them precisely.&lt;/p&gt;

&lt;p&gt;Step 6: keep a sign-off record&lt;/p&gt;

&lt;p&gt;The last step is the one that turns an engineering exercise into evidence. Record the decision to change as an event.&lt;/p&gt;

&lt;p&gt;python&lt;br&gt;
await db.log(agent="change-control", event="model_change_approved",&lt;br&gt;
    data={"from": {"model": "model-a", "prompt_v": "v14"},&lt;br&gt;
          "to": {"model": "candidate-model", "prompt_v": "v15"},&lt;br&gt;
          "test_set_size": 400, "agreement": "recorded in report",&lt;br&gt;
          "approver": "head-of-ml", "date": "2026-11-17"},&lt;br&gt;
    parent_id=None)&lt;/p&gt;

&lt;p&gt;Link it to the summary of test results. Keep the report with the record. Store your chain head outside the database so that the history cannot be quietly rewritten.&lt;/p&gt;

&lt;p&gt;This does three useful things. It answers customers who ask how you manage changes to the AI in your product. It gives your own team a record of why a change was made. And it supports the kind of record keeping that rules such as the EU AI Act point toward, for systems that fall under them. Article 12 of the Act concerns automatic recording of events over the lifetime of high risk systems. Whether a substantial change to your system triggers further obligations depends on your system and your role, so take legal advice on that.&lt;/p&gt;

&lt;p&gt;Three scenarios&lt;/p&gt;

&lt;p&gt;The following scenarios are illustrative composites, not real customers.&lt;/p&gt;

&lt;p&gt;Scenario 1: a forced upgrade with a deadline&lt;/p&gt;

&lt;p&gt;A provider announces that a model version will be retired in ninety days. A claims automation company has recorded eight months of cases. It builds a test set of 400 cases across five customers, including 60 where reviewers overrode the agent. The candidate replacement agrees with production on most cases, but on the overridden cases it matches the reviewer less often than the current model, in one customer's category only. Lineage shows the new model ignores a formatting rule in that customer's retrieved policy. A prompt adjustment fixes it, the replay is rerun and the canary proceeds. The deadline is met, and the team can show the customer how the change was tested.&lt;/p&gt;

&lt;p&gt;Scenario 2: switching to a cheaper model&lt;/p&gt;

&lt;p&gt;A legal tech company wants to cut costs. The replay shows the candidate costs far less per case and agrees with production on most cases, but the regression review finds that it misses a certain type of indemnity clause more often. The team decides to use the cheaper model for low-risk document types and keep the current one for the rest. The decision, the evidence and the routing rule are all recorded. The company saves money without taking a risk it cannot explain.&lt;/p&gt;

&lt;p&gt;Scenario 3: a prompt change to fix one complaint&lt;/p&gt;

&lt;p&gt;A bank's credit pre-assessment vendor edits a prompt to fix a customer complaint. The replay shows the edit fixes the complaint but raises the decline rate for a different segment. Without replay, this would have appeared weeks later as a drift signal and an angry client. With it, the vendor catches the side effect in an afternoon and revises the edit.&lt;/p&gt;

&lt;p&gt;Common pitfalls&lt;br&gt;
No versions recorded. If you did not log model and prompt versions, you cannot attribute a change to anything.&lt;br&gt;
A test set full of easy cases. Include the corrected and failed cases, or the test proves nothing.&lt;br&gt;
Judging after seeing the numbers. Write criteria first.&lt;br&gt;
One run of a probabilistic model. Repeat on samples where variance matters.&lt;br&gt;
Sending customer data to a new provider without checking contracts. A new provider may be a new subprocessor.&lt;br&gt;
Mixing shadow and production records. Keep separate agent names so baselines stay clean.&lt;br&gt;
Skipping the canary. Replay reduces risk. It does not remove it.&lt;br&gt;
No sign-off record. If the decision is not recorded, the next question from a customer or auditor is hard to answer.&lt;br&gt;
A one week plan&lt;/p&gt;

&lt;p&gt;Day 1: check that the record includes inputs, context, outputs, versions and human outcomes. Fix gaps. Day 2: build and freeze the test set, including corrected cases, with redaction applied. Day 3: run the candidate in shadow mode and log results with links to production decisions. Day 4: compare agreement, corrected case performance, regressions, cost and latency, by segment. Day 5: review disagreements with lineage, group them and adjust the prompt if needed, then rerun. Day 6: plan the canary, set rollback criteria and check contracts for any new subprocessor. Day 7: record the sign-off and begin the canary.&lt;/p&gt;

&lt;p&gt;Limits to remember&lt;/p&gt;

&lt;p&gt;ZizkaDB records, links and measures. It does not run your model, judge answers, or guarantee that a candidate will behave in production as it did in replay. Replay shows how the candidate handles past cases, and the future may differ. Outputs vary between runs. The corrected cases in your history reflect your reviewers' judgment, which may itself contain mistakes. The open source edition records one agent per install, so multi-customer and multi-agent setups use the Cloud edition. Confirm the specific features you rely on, such as iteration, export, baseline() and time travel, against the current documentation before you build on them.&lt;/p&gt;

&lt;p&gt;Get started&lt;/p&gt;

&lt;p&gt;Pick one agent and one upcoming change, whether a model upgrade, a cost saving or a prompt edit. Make sure versions and human outcomes are recorded, build a small test set that includes corrected cases, and run your first shadow replay. You will learn more from one afternoon of comparison than from a month of hoping.&lt;/p&gt;

&lt;p&gt;ZizkaDB runs self hosted in a single Docker container, with a managed Cloud edition at db.zizka.ai for multi-agent setups.&lt;/p&gt;

&lt;p&gt;Corrections: if you represent a party named here and believe a statement is inaccurate, contact us and we will review it promptly.&lt;/p&gt;

&lt;p&gt;Sources: ZizkaDB documentation; Regulation (EU) 2024/1689, the EU AI Act, Article 12.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>opensource</category>
      <category>openai</category>
      <category>llm</category>
    </item>
    <item>
      <title>How to Pass an Enterprise AI Security Review: Build an Evidence Pack That Closes Deals</title>
      <dc:creator>Mir Arshad Ali Talpur</dc:creator>
      <pubDate>Mon, 16 Nov 2026 10:11:41 +0000</pubDate>
      <link>https://dev.to/mir_arshadalitalpur_1b3/how-to-pass-an-enterprise-ai-security-review-build-an-evidence-pack-that-closes-deals-1o5m</link>
      <guid>https://dev.to/mir_arshadalitalpur_1b3/how-to-pass-an-enterprise-ai-security-review-build-an-evidence-pack-that-closes-deals-1o5m</guid>
      <description>&lt;p&gt;Your demo went well. The buyer's team is excited. Then the deal moves to security review, a questionnaire arrives with dozens of AI-specific questions, and the momentum stops. Weeks pass. Someone asks whether your agent logs are tamper-proof. Someone else asks how you would reconstruct a wrong decision for a regulator. Your best answer is a paragraph of reassurance.&lt;/p&gt;

&lt;p&gt;This is where many vertical AI deals are won or lost, and it is a problem you can prepare for. This guide shows how to build an evidence pack: a small, standing set of artifacts that answers the AI-specific questions with records instead of promises. It covers what reviews now ask, the five questions that decide most of them, the pack itself, how to run a live replay in the buyer meeting, and a two week plan to get it done.&lt;/p&gt;

&lt;p&gt;The audit layer we use in the examples is ZizkaDB, an open source causal audit database for AI agents. The method applies to any tool that gives you a causally linked, tamper-evident record. What matters is that you can show the buyer what your agent did, not just tell them.&lt;/p&gt;

&lt;p&gt;A note on scope. This is general guidance, not legal advice, and ZizkaDB does not by itself make any system compliant with the EU AI Act, SOC 2, ISO 42001 or any other framework. ZizkaDB does not hold those certifications and nothing here suggests it does. Code parameter names are illustrative and should be checked against the SDK reference. Where we describe what buyers ask, we draw on public practitioner guides, listed at the end, which vary in quality and are not official standards.&lt;/p&gt;

&lt;p&gt;What changed in enterprise security reviews&lt;/p&gt;

&lt;p&gt;A few years ago, a security review of a software vendor looked at encryption, access control, uptime and the vendor's own certifications. Those questions still matter. For AI products, practitioner guides report that they are no longer enough.&lt;/p&gt;

&lt;p&gt;Several recent guides make the same points. A SOC 2 report remains the front gate at most enterprise buyers, but it was not designed to evaluate AI-specific risk, so it is no longer the finish line. ISO/IEC 42001, the first certifiable AI management system standard, is increasingly listed as preferred or required in procurement templates, according to practitioner commentary. And AI questionnaires now ask things standard ones never did: whether prompts become training data, who the model subprocessors are, how the vendor handles prompt injection, and what is logged and for how long.&lt;/p&gt;

&lt;p&gt;One security guide for SaaS vendors puts the shift in a sentence worth remembering: when a buyer's questionnaire asks you to prove what your AI did, you attach records rather than assurances. That is the idea behind the evidence pack.&lt;/p&gt;

&lt;p&gt;The reason buyers ask is simple. Enterprise buyers cannot push these questions up the supply chain to the model provider, so they push them down to you. If your product makes or shapes decisions, their auditors, regulators and boards will ask them what happened when it goes wrong. They need you to help them answer.&lt;/p&gt;

&lt;p&gt;The five questions that decide most reviews&lt;/p&gt;

&lt;p&gt;Reviews vary, but five questions come up in nearly every serious one. For each, here is the answer that stalls a deal and the answer that moves it.&lt;/p&gt;

&lt;p&gt;The question    The answer that stalls  The answer with evidence&lt;br&gt;
What did your AI do on our data, and can you prove it?  We log everything and our team can look into it Here is a sample trace of a real case, from input to output, with the chain verified&lt;br&gt;
How do you detect when its behaviour changes?   We test before each release Here is a drift report per customer, with model and prompt versions recorded&lt;br&gt;
How do you handle prompt injection and untrusted input? We use filters and guardrails   Here is how external content is tagged, and here is a trace showing what depended on it&lt;br&gt;
What do you log, where does it live, and for how long?  Logs are encrypted and retained as needed   Here is the data map: what is stored, what is redacted, retention, residency and erasure&lt;br&gt;
How do you show human oversight, and how fast can you respond to an incident?   Our reviewers check outputs Here is the review record, and here is the timed exercise of reconstructing a past incident&lt;/p&gt;

&lt;p&gt;The pattern is the same each time. The stalling answer describes intent. The strong answer shows an artifact. A security reviewer who can open an artifact spends less time worrying and more time ticking boxes.&lt;/p&gt;

&lt;p&gt;The evidence pack, component by component&lt;/p&gt;

&lt;p&gt;The pack is eight small artifacts. You build them once, keep them current, and attach the relevant ones to each review. None needs to be long.&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;&lt;p&gt;A one page architecture and data flow. A single diagram showing where customer data enters, which models and subprocessors touch it, where it is stored and where the audit record lives. Reviewers read this first. Keep it accurate, because a mismatch between the diagram and your answers costs trust.&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;The event model. A short table of what your agents record: task received, context retrieved, model call, decision, tool call, human review, output delivered. For each, say what fields are captured, including model and prompt versions and the customer identifier. This shows the record is designed, not accidental.&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;A sample trace. One real case, redacted, exported as a causal chain from the incoming request to the final output, with the human review included. This is the most persuasive artifact in the pack, because it shows lineage on something real.&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;A drift report. A per customer view comparing recent behaviour against a baseline period: approval rates, time per task, tool mix, review edit rate. It shows that you measure change instead of assuming stability.&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;An integrity proof. The result of running chain verification on the record, plus a description of where the chain head is stored outside the database. It shows that an administrator cannot quietly rewrite history. Be precise about what this proves: that the record is unchanged, not that the agent was right.&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;A data handling statement. What is stored and what is redacted before storage, retention periods, deployment options for data residency, and how erasure requests are handled. This answers the concern raised in some guides that logging can create a second sensitive dataset, so say plainly how you prevent that.&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;An incident playbook with a timing test. A one page procedure for reconstructing an event, plus the result of a timed exercise: pick a past case, start a clock, and record how long it took to answer what the agent read, what it decided, who reviewed it and which other cases were affected.&lt;/p&gt;&lt;/li&gt;
&lt;li&gt;&lt;p&gt;An evidence window. A description of how a customer or auditor gets read-only, time limited access to inspect their own record. This is your strongest signal of confidence.&lt;/p&gt;&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Building the pack in practice&lt;br&gt;
Make sure the record exists first&lt;/p&gt;

&lt;p&gt;Everything above depends on instrumentation. Before you build the pack, check that your agents record causal links and versions. An illustrative pattern, with parameter names to be checked against the SDK reference:&lt;/p&gt;

&lt;p&gt;python&lt;br&gt;
task = await db.log(agent="review-agent", event="task_received",&lt;br&gt;
    data={"customer": "acme", "type": "contract_review", "case": "K-2041"})&lt;/p&gt;

&lt;p&gt;ctx = await db.log(agent="review-agent", event="context_retrieved",&lt;br&gt;
    data={"source": "playbook", "rule": "liability-cap", "rule_v": "v7",&lt;br&gt;
          "trust": "trusted"},&lt;br&gt;
    parent_id=task.id)&lt;/p&gt;

&lt;p&gt;dec = await db.log(agent="review-agent", event="decision",&lt;br&gt;
    data={"outcome": "flag", "clause": "12.3", "prompt_v": "v14",&lt;br&gt;
          "model": "provider-model-2026-09"},&lt;br&gt;
    parent_id=ctx.id)&lt;/p&gt;

&lt;p&gt;review = await db.log(agent="review-agent", event="human_review",&lt;br&gt;
    data={"reviewer": "r-204", "action": "accepted", "seconds_spent": 41},&lt;br&gt;
    parent_id=dec.id)&lt;/p&gt;

&lt;p&gt;Then run the lineage on the decision and keep the output:&lt;/p&gt;

&lt;p&gt;python&lt;br&gt;
(await db.why(dec.id)).print()&lt;/p&gt;

&lt;p&gt;That output, redacted and formatted, becomes your sample trace.&lt;/p&gt;

&lt;p&gt;Export the sample trace&lt;/p&gt;

&lt;p&gt;Choose a case that is representative but unremarkable. Redact personal and confidential values before sharing, and confirm with your legal team that the case can be used. The point is to show structure, so the content can be synthetic if you prefer. Annotate the trace with plain language: this is the input, this is what was retrieved, this is the decision, this is the person who approved it.&lt;/p&gt;

&lt;p&gt;Produce the drift report&lt;/p&gt;

&lt;p&gt;Choose a stable period as the baseline and compare the latest week against it, per customer. ZizkaDB's baseline() supports this kind of comparison. Record model and prompt versions on every model call so that any shift can be matched to a change. A drift report that shows stability is useful. A report that shows a shift you caught and explained is better, because it proves the process works.&lt;/p&gt;

&lt;p&gt;Verify the chain and store the head elsewhere&lt;/p&gt;

&lt;p&gt;Each event carries a SHA-256 checksum and is chained to the previous event for that agent, so editing an old event breaks the chain. Run chain verification on a schedule. Store the chain head in a system that database administrators cannot edit, so that nobody can rewrite both the history and its head. Keep a dated record of each successful verification for the pack.&lt;/p&gt;

&lt;p&gt;Document data handling honestly&lt;/p&gt;

&lt;p&gt;Describe what you actually do. If redaction happens before storage, say which patterns are covered. If full content is stored for some workflows and only metadata for others, say which. Include retention periods and how erasure requests flow through to the record. If you offer a self hosted deployment inside the customer's own environment for data residency, say so. Whether you may store particular data, and for how long, depends on your contracts and on data protection law, so involve whoever owns that question.&lt;/p&gt;

&lt;p&gt;Time the incident exercise&lt;/p&gt;

&lt;p&gt;Pick a past case and a colleague who did not work on it. Start a clock. Ask the colleague to answer four questions from the record alone: what did the agent read, what did it decide because of that, who reviewed it and what did they see, and which other cases used the same inputs. Write down the time and the gaps. Fix the gaps and repeat. A documented exercise carries far more weight than a statement that you can respond quickly.&lt;/p&gt;

&lt;p&gt;Set up the evidence window&lt;/p&gt;

&lt;p&gt;Create a read-only, expiring key scoped to a single customer's record. Test it as the customer would: can they see what they should, and nothing else? Describe the process in a short document so that you can offer it during a pilot.&lt;/p&gt;

&lt;p&gt;Running a live replay in the buyer meeting&lt;/p&gt;

&lt;p&gt;The most effective moment in a security review is a live replay. It takes ten minutes and it changes the tone of the conversation. A simple script:&lt;/p&gt;

&lt;p&gt;Set the scene. Pick a case the buyer's team chooses or approves, ideally from a pilot or a representative sample.&lt;br&gt;
Start from the output. Show the final result and ask the room what question they would ask if this were wrong.&lt;br&gt;
Walk backwards. Run the lineage from the output through the human review, the decision, the retrieved context, to the original request. Narrate each link.&lt;br&gt;
Show the versions. Point out the model and prompt versions on the decision.&lt;br&gt;
Show the human. Show what the reviewer saw and how long they spent.&lt;br&gt;
Show the proof. Run chain verification and explain what it does and does not prove.&lt;br&gt;
Answer the scope question. Show how you would list every other case that used the same input.&lt;/p&gt;

&lt;p&gt;A sceptical CISO who watches a decision traced back to its inputs in seconds understands your answer to the logging question better than any document could convey. Practise the replay beforehand on a case you have not seen, so that any surprises happen in rehearsal.&lt;/p&gt;

&lt;p&gt;Handling the hard objections&lt;/p&gt;

&lt;p&gt;We do not want another copy of our sensitive data. This is a fair concern. Offer metadata-only recording for sensitive workflows, redaction before storage, self hosting in their environment, short retention and erasure on request. Show the data handling statement.&lt;/p&gt;

&lt;p&gt;Logs are not evidence. Agree, and explain the difference. A mutable log table proves little. A record with checksums and a hash chain, with the head stored elsewhere, makes edits detectable. Be clear about the limit: it shows the record is unchanged, not that the content was correct.&lt;/p&gt;

&lt;p&gt;Our auditors want a certification. Be honest about where you are. An audit layer gives AI-specific evidence that SOC 2 and ISO 42001 do not directly provide, but it does not replace them. If you are working toward certifications, say so and share the plan. If you hold them, share the reports and be precise about scope, since some certifications exclude AI processing.&lt;/p&gt;

&lt;p&gt;How do we know the AI is not being manipulated? Be candid. An audit layer records what the agent read and did and lets you trace what depended on any input. It does not detect manipulation or judge truth. Describe your prevention layers separately, such as input handling, least privilege and sandboxing, and show how the record supports investigation if prevention fails.&lt;/p&gt;

&lt;p&gt;What about the EU AI Act? Explain what you know and avoid overclaiming, as covered next.&lt;/p&gt;

&lt;p&gt;The regulatory context, briefly&lt;/p&gt;

&lt;p&gt;Buyers in regulated sectors increasingly ask how your product fits the EU AI Act. Three provisions are most relevant to record keeping and oversight. Article 12 requires high risk AI systems to support automatic recording of events over their lifetime. Article 14 covers human oversight, and recognises the risk of automation bias. Article 73 sets serious incident reporting timelines, which differ by the kind of incident.&lt;/p&gt;

&lt;p&gt;On timing, the Digital Omnibus on AI, Regulation (EU) 2026/1744, moved the application date for stand-alone high risk systems under Annex III to 2 December 2027, and for high risk systems embedded in regulated products under Annex I to 2 August 2028, according to published legal summaries. Commentators stress that the work does not go away, and buyers are asking now, since their own procurement and risk teams are preparing.&lt;/p&gt;

&lt;p&gt;Whether your product is high risk depends on its intended purpose, and your obligations depend on your role. Take legal advice on both. What the evidence pack gives you is a set of artifacts that support the conversation: a record of events, evidence of oversight and a tested ability to reconstruct an incident. ZizkaDB supports record keeping and investigation. It does not by itself deliver compliance.&lt;/p&gt;

&lt;p&gt;A two week plan&lt;/p&gt;

&lt;p&gt;You can build a working pack in two weeks, starting from one agent and one customer.&lt;/p&gt;

&lt;p&gt;Week 1: record and measure.&lt;/p&gt;

&lt;p&gt;Day 1 to 2: check that causal links, model and prompt versions, customer identifiers and human review events are recorded. Fix gaps.&lt;br&gt;
Day 3: configure redaction and retention, and write the data handling statement.&lt;br&gt;
Day 4: export and annotate a sample trace.&lt;br&gt;
Day 5: choose a baseline period and produce a first drift report.&lt;/p&gt;

&lt;p&gt;Week 2: prove and present.&lt;/p&gt;

&lt;p&gt;Day 6: run chain verification, set up the schedule and store the chain head outside the database.&lt;br&gt;
Day 7 to 8: run and time the incident exercise, and fix the gaps.&lt;br&gt;
Day 9: set up and test the read-only evidence window.&lt;br&gt;
Day 10: write the one page architecture and the event model table.&lt;br&gt;
Day 11 to 12: assemble the pack and update your standard questionnaire answers.&lt;br&gt;
Day 13 to 14: rehearse the live replay with sales and engineering, and have counsel review the claims.&lt;br&gt;
Common mistakes&lt;br&gt;
Describing instead of showing. Every claim in the pack should point to an artifact.&lt;br&gt;
Overclaiming. Say that the system records, traces, measures and proves the record. Do not say it guarantees correctness or compliance.&lt;br&gt;
A stale pack. An out of date diagram or an expired verification record is worse than none. Assign an owner and a review date.&lt;br&gt;
Storing too much. An audit record full of raw sensitive content can become the thing the buyer worries about. Decide what to keep.&lt;br&gt;
Ignoring versions. Without model and prompt versions, you cannot explain a change in behaviour.&lt;br&gt;
Letting the head live in the same place as the chain. If the same administrator can edit both, the integrity claim is weak.&lt;br&gt;
Leaving sales out. If the sales team cannot run the replay, the pack stays in engineering and the deal still stalls.&lt;br&gt;
Limits to remember&lt;/p&gt;

&lt;p&gt;ZizkaDB records, links, measures and proves that the record is unchanged. It does not make an agent correct, block harmful actions, detect manipulation or judge whether an output is true. The open source edition records one agent per install, so multi-customer and multi-agent setups use the Cloud edition. Confirm the specific features you rely on, such as baseline(), the impact route and read-only keys, against the current documentation before you describe them to a buyer. And have counsel check how regulation and your contracts apply to your product.&lt;/p&gt;

&lt;p&gt;Get started&lt;/p&gt;

&lt;p&gt;Pick one agent and one customer. Make sure the causal links and versions are recorded, export a sample trace, and time an incident exercise. You will learn more in one afternoon than in a month of drafting questionnaire answers, and you will have something real to show the next time a buyer asks what your AI did.&lt;/p&gt;

&lt;p&gt;ZizkaDB runs self hosted in a single Docker container, with a managed Cloud edition at db.zizka.ai for multi-agent setups.&lt;/p&gt;

&lt;p&gt;Corrections: if you represent a party named here and believe a statement is inaccurate, contact us and we will review it promptly.&lt;/p&gt;

&lt;p&gt;Sources: practitioner guides on enterprise AI security questionnaires, including Tian Pan (80 question wall, April 2026), DeepInspect (SaaS guide to AI security questionnaires) and Wavect (EU AI vendor security questionnaire); legal summaries of the Digital Omnibus on AI from DLA Piper, Orrick and VDA; Regulation (EU) 2024/1689, Articles 12, 14 and 73; ZizkaDB documentation.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>opensource</category>
      <category>enterprisereadiness</category>
      <category>euaiact</category>
    </item>
    <item>
      <title>ZizkaDB Redu Cloud: Bringing Operational Intelligence and Agent-Native Infrastructure Together</title>
      <dc:creator>Mir Arshad Ali Talpur</dc:creator>
      <pubDate>Sat, 14 Nov 2026 12:24:42 +0000</pubDate>
      <link>https://dev.to/mir_arshadalitalpur_1b3/zizkadb-x-redu-cloud-bringing-operational-intelligence-and-agent-native-infrastructure-together-4ph0</link>
      <guid>https://dev.to/mir_arshadalitalpur_1b3/zizkadb-x-redu-cloud-bringing-operational-intelligence-and-agent-native-infrastructure-together-4ph0</guid>
      <description>&lt;p&gt;Two European technology companies join forces to make AI agents more reliable, auditable, and production-ready.&lt;/p&gt;

&lt;p&gt;We are excited to announce our design partnership with redu.cloud, an agent-native cloud platform built to help AI agents deploy, operate, and manage real infrastructure.&lt;/p&gt;

&lt;p&gt;At ZizkaDB, we believe the next generation of software infrastructure will be built around AI agents. But making agents work in production requires more than powerful models. It requires reliable infrastructure, operational visibility, auditability, and control over data.&lt;/p&gt;

&lt;p&gt;That’s exactly where ZizkaDB and Redu Cloud come together.&lt;/p&gt;

&lt;p&gt;Both companies are already serving customers across their respective cloud and enterprise markets. This partnership brings our capabilities closer together, creating a more complete infrastructure foundation for companies building and deploying AI agents at scale.&lt;/p&gt;

&lt;p&gt;Two complementary pieces of the AI infrastructure stack&lt;br&gt;
AI agents are moving beyond experimentation. Companies are increasingly deploying autonomous systems that interact with customers, execute workflows, access business data, and make decisions.&lt;/p&gt;

&lt;p&gt;As adoption grows, two fundamental questions emerge:&lt;/p&gt;

&lt;p&gt;Where do AI agents run, and how can their infrastructure be managed efficiently?&lt;br&gt;
How do companies understand, audit, and improve what their agents actually do?&lt;br&gt;
ZizkaDB and Redu Cloud address these complementary challenges.&lt;/p&gt;

&lt;p&gt;ZizkaDB: Operational intelligence for AI agents&lt;br&gt;
ZizkaDB is a database built specifically for AI agents in production.&lt;/p&gt;

&lt;p&gt;Traditional observability tools provide logs, traces, and metrics. But when an AI agent makes an unexpected decision, teams need more than a collection of events. They need to understand the complete context behind its behavior.&lt;/p&gt;

&lt;p&gt;ZizkaDB provides:&lt;/p&gt;

&lt;p&gt;Session replay: Reconstruct agent sessions and understand what happened from beginning to end.&lt;br&gt;
Causal lineage: Trace the decision chain behind an agent’s actions and understand why it made a particular choice.&lt;br&gt;
Drift detection: Identify behavioral changes following model, prompt, or configuration updates.&lt;br&gt;
Operational visibility: Give engineering and operations teams a structured view of agent activity across production environments.&lt;br&gt;
Available as open-source software and managed cloud, ZizkaDB gives teams the flexibility to deploy according to their infrastructure and operational requirements.&lt;/p&gt;

&lt;p&gt;Redu Cloud: Infrastructure built for AI agents&lt;br&gt;
Redu Cloud approaches the infrastructure side of the equation.&lt;/p&gt;

&lt;p&gt;Traditional cloud platforms were designed primarily around human-operated infrastructure workflows. Redu Cloud is built around a different idea: AI agents should be able to provision, deploy, operate, and maintain the infrastructure they need.&lt;/p&gt;

&lt;p&gt;Through its agent-native approach and Model Context Protocol (MCP) integration, Redu Cloud enables AI agents to work directly with real cloud infrastructure.&lt;/p&gt;

&lt;p&gt;Its capabilities include:&lt;/p&gt;

&lt;p&gt;Compute instances and virtual machines.&lt;br&gt;
Managed databases and persistent storage.&lt;br&gt;
Private networks and load balancing.&lt;br&gt;
Autoscaling infrastructure.&lt;br&gt;
Agent-driven deployment and infrastructure operations.&lt;br&gt;
With EU-based infrastructure and data residency in Germany, Redu Cloud also provides an important foundation for companies building AI products with European data requirements.&lt;/p&gt;

&lt;p&gt;What the partnership brings to customers&lt;br&gt;
The combination of ZizkaDB and Redu Cloud connects two important layers of production AI infrastructure.&lt;/p&gt;

&lt;p&gt;Redu Cloud provides the environment where AI applications and agents run. ZizkaDB provides the operational intelligence needed to understand, audit, and improve their behavior.&lt;/p&gt;

&lt;p&gt;Together, we aim to bring four important benefits to AI-native companies:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Agent auditability&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;As agents become responsible for increasingly important workflows, understanding their decisions becomes essential. ZizkaDB gives teams the ability to replay sessions, trace decisions, and investigate unexpected behavior.&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Infrastructure speed&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Redu Cloud allows agents to interact directly with infrastructure, reducing the friction between development, deployment, and operations.&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Cost optimization&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Companies can combine agent-driven infrastructure management with flexible ZizkaDB deployment options, helping them build a more cost-conscious production stack.&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;European data residency&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;For companies operating in regulated or data-sensitive markets, having infrastructure and operational data options aligned with European requirements is increasingly important.&lt;/p&gt;

&lt;p&gt;Our shared objective is to make these capabilities accessible without forcing companies to assemble and maintain multiple disconnected systems.&lt;/p&gt;

&lt;p&gt;Getting started with ZizkaDB on Redu Cloud&lt;br&gt;
Starting today, ZizkaDB can be used natively with Redu Cloud in three ways.&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Open-source deployment
ZizkaDB Open Source is already available on Redu Cloud.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Developers can deploy ZizkaDB directly on Redu Cloud infrastructure and connect it to their AI agents.&lt;/p&gt;

&lt;p&gt;This provides a straightforward way to get started with agent observability and operational intelligence while retaining control over the deployment environment.&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;ZizkaDB managed cloud plans
We are also preparing two new ZizkaDB managed cloud plans in collaboration with Redu Cloud.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;These plans are designed with vertical AI companies and growing agent-native businesses in mind.&lt;/p&gt;

&lt;p&gt;Plan 1: Up to 2.5 million events, with cost-effective pricing.&lt;br&gt;
Plan 2: Up to 7.5 million events, with cost-effective pricing.&lt;br&gt;
Both plans will be available soon.&lt;/p&gt;

&lt;p&gt;The goal is to give teams a straightforward path to managed agent data infrastructure without having to operate everything themselves.&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Enterprise deployments with VPC
For larger organizations with specific security, networking, and infrastructure requirements, ZizkaDB and Redu Cloud will support enterprise deployments with Virtual Private Cloud (VPC) options.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Companies interested in this setup can contact either team directly to discuss their requirements.&lt;/p&gt;

&lt;p&gt;Building the infrastructure layer for the agent economy&lt;br&gt;
We believe the AI infrastructure market is entering a new phase.&lt;/p&gt;

&lt;p&gt;The first generation of AI products focused on model access, prompting, and application development. The next generation will require durable infrastructure capable of supporting autonomous systems in real production environments.&lt;/p&gt;

&lt;p&gt;That means infrastructure must evolve.&lt;/p&gt;

&lt;p&gt;AI agents need environments where they can operate. Businesses need visibility into what those agents do. Engineering teams need the ability to investigate failures, understand decisions, optimize costs, and maintain control over their systems.&lt;/p&gt;

&lt;p&gt;No single product needs to solve every part of this challenge.&lt;/p&gt;

&lt;p&gt;The opportunity lies in bringing specialized, complementary technologies together.&lt;/p&gt;

&lt;p&gt;ZizkaDB and Redu Cloud are already building and serving customers in their respective domains. This partnership is a natural next step: combining operational intelligence with agent-native cloud infrastructure to serve a broader market.&lt;/p&gt;

&lt;p&gt;We are excited about what we can build together and look forward to making production AI infrastructure more accessible to companies in Europe and beyond.&lt;/p&gt;

&lt;p&gt;Build with ZizkaDB. Deploy with Redu Cloud. Make your AI agents production-ready.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>opensource</category>
      <category>zizkadb</category>
      <category>cloudinfra</category>
    </item>
    <item>
      <title>How to Add ZizkaDB to OpenClaw: A Tamper-Evident Audit Trail for Every Agent Turn</title>
      <dc:creator>Mir Arshad Ali Talpur</dc:creator>
      <pubDate>Fri, 13 Nov 2026 11:24:32 +0000</pubDate>
      <link>https://dev.to/mir_arshadalitalpur_1b3/how-to-add-zizkadb-to-openclaw-a-tamper-evident-audit-trail-for-every-agent-turn-1fjo</link>
      <guid>https://dev.to/mir_arshadalitalpur_1b3/how-to-add-zizkadb-to-openclaw-a-tamper-evident-audit-trail-for-every-agent-turn-1fjo</guid>
      <description>&lt;p&gt;If you run agents on OpenClaw, you already have logs. What you probably do not have is a record that answers three questions after something goes wrong: what did the agent receive, which tool call followed because of it, and can anyone show the record was not edited afterwards? This guide shows how to add ZizkaDB to OpenClaw with the ZizkaDB plugin, so each turn is recorded as a causally linked, tamper-evident audit trail.&lt;/p&gt;

&lt;p&gt;The setup takes a few minutes. The business value is that the next time an agent sends the wrong message or calls the wrong tool, you replay the turn instead of guessing.&lt;/p&gt;

&lt;p&gt;A note on scope. ZizkaDB is an independent project and is not affiliated with or endorsed by OpenClaw. The plugin details below come from the plugin's ClawHub listing (version 0.1.1 when we checked on 12 November 2026) and OpenClaw's plugin documentation. Plugin versions change, so check the listing before you rely on a specific option.&lt;/p&gt;

&lt;p&gt;What you get&lt;/p&gt;

&lt;p&gt;The ZizkaDB plugin records each OpenClaw agent turn in ZizkaDB. According to its listing, recorded items include messages, tool calls, model outputs, token usage and replies. Each OpenClaw turn becomes one hash chain, and each conversation session maps to a ZizkaDB session. Tamper evidence comes from per agent hash chaining, which you can verify through the ZizkaDB API.&lt;/p&gt;

&lt;p&gt;Two design choices make it safe to try. The plugin is observe-only: it does not block, alter or delay messages or tool calls, and a failed write does not affect the agent. And the optional in-agent tools are off by default.&lt;/p&gt;

&lt;p&gt;Before you start&lt;/p&gt;

&lt;p&gt;You need three things:&lt;/p&gt;

&lt;p&gt;A running OpenClaw gateway. The plugin records inside the running gateway, so it covers chat channels, cron jobs and openclaw agent turns.&lt;br&gt;
A ZizkaDB server. Use ZizkaDB Cloud at db.zizka.ai with an API key, or self host the open source server, which runs from a single docker command.&lt;br&gt;
A supported Node.js version. The listing names Node.js 24.16 or later, which it describes as OpenClaw's own requirement.&lt;br&gt;
Step 1: install the plugin&lt;/p&gt;

&lt;p&gt;From ClawHub, run:&lt;/p&gt;

&lt;p&gt;bash&lt;br&gt;
openclaw plugins install clawhub:@zizka-ai/zizkadb&lt;/p&gt;

&lt;p&gt;You can also install it from npm. Installs from outside ClawHub need the force flag:&lt;/p&gt;

&lt;p&gt;bash&lt;br&gt;
openclaw plugins install npm:zizkadb-openclaw --force&lt;/p&gt;

&lt;p&gt;OpenClaw asks you to approve the plugin's permissions during install. In scripts, you can pass the accept capabilities flag instead of answering the prompt. Read the permission list before approving, as you would for any plugin that touches conversation data.&lt;/p&gt;

&lt;p&gt;OpenClaw documents the clawhub and npm source prefixes so you can pick the source explicitly. Without a prefix, bare package names may resolve differently depending on your OpenClaw version.&lt;/p&gt;

&lt;p&gt;Step 2: configure openclaw.json&lt;/p&gt;

&lt;p&gt;Edit the OpenClaw config file, usually at ~/.openclaw/openclaw.json, and restart the gateway afterwards. The listing names these settings:&lt;/p&gt;

&lt;p&gt;plugins.allow should include zizkadb.&lt;br&gt;
plugins.entries.zizkadb.enabled should be true.&lt;br&gt;
hooks.allowConversationAccess should be true if you want model outputs and token usage recorded. Without it, messages and tool activity are still recorded, and the gateway log notes the gap at startup.&lt;br&gt;
config.apiKey holds your ZizkaDB key, from Cloud settings or your own server.&lt;br&gt;
config.host is the server URL for self hosted use, for example &lt;a href="http://localhost:8000" rel="noopener noreferrer"&gt;http://localhost:8000&lt;/a&gt;.&lt;br&gt;
config.agent is the agent name inside ZizkaDB. The default is openclaw.&lt;br&gt;
config.captureContent controls whether content is stored (see Step 5).&lt;/p&gt;

&lt;p&gt;You can use the environment variables ZIZKADB_API_KEY and ZIZKADB_HOST instead of putting the key and host in the file. That keeps secrets out of a config you might commit or share. An illustrative layout, to be checked against the listing:&lt;/p&gt;

&lt;p&gt;json&lt;br&gt;
{&lt;br&gt;
  "plugins": {&lt;br&gt;
    "allow": ["zizkadb"],&lt;br&gt;
    "entries": {&lt;br&gt;
      "zizkadb": {&lt;br&gt;
        "enabled": true,&lt;br&gt;
        "config": { "host": "&lt;a href="http://localhost:8000" rel="noopener noreferrer"&gt;http://localhost:8000&lt;/a&gt;", "agent": "support-bot" }&lt;br&gt;
      }&lt;br&gt;
    }&lt;br&gt;
  },&lt;br&gt;
  "hooks": { "allowConversationAccess": true }&lt;br&gt;
}&lt;/p&gt;

&lt;p&gt;Give each agent its own name through config.agent. ZizkaDB keeps a hash chain per agent, so distinct names keep your audit trails separate.&lt;/p&gt;

&lt;p&gt;Step 3: verify it loaded&lt;/p&gt;

&lt;p&gt;OpenClaw's plugin documentation describes an inspect command with a runtime flag for proving that a plugin registered its hooks and tools:&lt;/p&gt;

&lt;p&gt;bash&lt;br&gt;
openclaw plugins inspect zizkadb --runtime --json&lt;/p&gt;

&lt;p&gt;Then send your agent a message through a normal channel and open the ZizkaDB dashboard. You should see a session with the turn in it. If nothing appears, check that the gateway was restarted after the config change, and remember that one-shot openclaw agent --local runs are not recorded, because recording happens in the running gateway.&lt;/p&gt;

&lt;p&gt;Step 4: see what gets recorded&lt;/p&gt;

&lt;p&gt;The listing maps OpenClaw hooks to ZizkaDB events:&lt;/p&gt;

&lt;p&gt;What happens in OpenClaw    ZizkaDB event   What is captured&lt;br&gt;
A message arrives   user_message    Text, sender, media count&lt;br&gt;
A tool is called    tool_call, then tool_result or tool_error   Tool name, arguments, result or error, duration&lt;br&gt;
The model answers   llm_end Provider, model, answer, token usage&lt;br&gt;
A reply is sent assistant_response  Sent text, delivery success&lt;br&gt;
A run fails agent_error Error, duration&lt;/p&gt;

&lt;p&gt;Events carry metadata including the source, the agent ID and the channel. Values longer than 8,000 characters are truncated, so very long tool results are stored in shortened form.&lt;/p&gt;

&lt;p&gt;For a business reader, the useful part is the chain. A user message leads to a tool call, which leads to a result, which leads to a reply. When the reply is wrong, you start from it and walk backwards.&lt;/p&gt;

&lt;p&gt;Step 5: decide what content to store&lt;/p&gt;

&lt;p&gt;Conversation content can be sensitive. The plugin gives you a switch. When config.captureContent is false, prompts, replies, tool arguments and tool results are not stored. Tool names, models, token usage and errors are still recorded.&lt;/p&gt;

&lt;p&gt;A sensible approach is to start with content capture off for any agent that handles personal or regulated data, and turn it on only where you have a reason and a legal basis for keeping it. You keep the shape of what happened, which tools ran, how often they failed and what they cost, without keeping the words. Whether you may store a given conversation depends on your data protection obligations, so check with whoever owns that for your organisation.&lt;/p&gt;

&lt;p&gt;Step 6: add the optional in-agent tools&lt;/p&gt;

&lt;p&gt;Two tools are off by default: zizkadb_why, which returns the causal chain behind an event, and zizkadb_search, which searches past events. Enable them with tools.alsoAllow set to both names.&lt;/p&gt;

&lt;p&gt;Per the listing, each tool is limited to the current conversation, the scope comes from OpenClaw's trusted session context and not from model arguments, and results are labelled as untrusted historical data. Agent wide audits need the dashboard or the SDK with your own key. That design matters: an agent can look back at its own conversation without being able to read other customers' histories.&lt;/p&gt;

&lt;p&gt;Step 7: query the trail&lt;/p&gt;

&lt;p&gt;For investigation outside the agent, use the zizkadb-sdk package. According to the listing, db.query finds recent events and db.why walks back the causal chain from an event. A minimal sketch, with parameter names to be checked against the SDK reference:&lt;/p&gt;

&lt;p&gt;python&lt;br&gt;
recent = await db.query(agent="support-bot", event="tool_error", limit=20)&lt;br&gt;
(await db.why(recent[0].id)).print()&lt;/p&gt;

&lt;p&gt;The dashboard shows sessions, the causal graph, tool error rates and token costs, which is useful for the people who do not write code: support leads, finance and compliance.&lt;/p&gt;

&lt;p&gt;Step 8: verify the chain and keep the head somewhere else&lt;/p&gt;

&lt;p&gt;A per agent hash chain makes later edits to the record detectable. You can check it through the chain endpoint at GET /v1/events/chain. Run the check on a schedule and store the chain head outside the ZizkaDB database, for example in a separate system, so that nobody with database access can rewrite both the history and its head. The chain shows that the record is unchanged. It does not show that the agent was right.&lt;/p&gt;

&lt;p&gt;Gotchas&lt;br&gt;
Restart the gateway after any config change. The plugin runs inside it.&lt;br&gt;
Without hooks.allowConversationAccess, you lose model outputs and token usage. Messages and tool activity still record.&lt;br&gt;
One-shot local runs are not recorded.&lt;br&gt;
Long values are truncated at 8,000 characters.&lt;br&gt;
Installing from npm outside ClawHub needs the force flag.&lt;br&gt;
Do not paste API keys into shared config files. Use the environment variables.&lt;br&gt;
Why this matters beyond debugging&lt;/p&gt;

&lt;p&gt;Three business outcomes follow from this setup.&lt;/p&gt;

&lt;p&gt;Faster incident response. When a customer complains about an agent action, you open the turn, read the chain and answer in minutes.&lt;/p&gt;

&lt;p&gt;Cost visibility. Token usage is recorded per model call, so you can see which agents and tools drive spend.&lt;/p&gt;

&lt;p&gt;Evidence for oversight and record keeping. If your agents fall under rules such as EU AI Act Article 12 on automatic event recording for high risk systems, a causally linked, tamper-evident record is the kind of evidence that points toward. Whether a given system is high risk depends on what it does. ZizkaDB supports record keeping and investigation. It is not legal advice and does not by itself make any system compliant with the EU AI Act or any other law.&lt;/p&gt;

&lt;p&gt;If your OpenClaw agents also read content from other agents, for instance on a social network such as Moltbook, which researchers have reported runs mostly on OpenClaw agents, the same trail lets you trace what an agent read before it acted. ZizkaDB records that. It cannot tell whether content was malicious or true, and it does not stop an agent from being persuaded.&lt;/p&gt;

&lt;p&gt;Limits to remember&lt;/p&gt;

&lt;p&gt;The plugin records. It does not block or filter anything, so it complements least privilege and sandboxing and does not replace them. The ClawHub listing shows an automated security scan as passing, which is an automated check and not a guarantee, so review the permissions yourself. The open source edition of ZizkaDB records one agent per install, and fleets or agent to agent tracing use the Cloud edition.&lt;/p&gt;

&lt;p&gt;Get started&lt;/p&gt;

&lt;p&gt;Install the plugin, give one agent its own name, run it for a day with content capture off, and open the dashboard. Then pick a single tool call and run why() on it. That is the first answer your current logs cannot give.&lt;/p&gt;

&lt;p&gt;Corrections: if you represent a party named here and believe a statement is inaccurate, contact us and we will review it promptly.&lt;/p&gt;

&lt;p&gt;Sources: ClawHub listing for the ZizkaDB OpenClaw plugin (clawhub.ai/zizka-ai/plugins/zizkadb); OpenClaw documentation, Plugins and Manage plugins (docs.openclaw.ai).&lt;/p&gt;

</description>
      <category>openclaw</category>
      <category>agentdrift</category>
      <category>opensource</category>
    </item>
    <item>
      <title>How to Make Your Moltbook Agent Reliable: A Practical Guide to Agent Auditability with ZizkaDB</title>
      <dc:creator>Mir Arshad Ali Talpur</dc:creator>
      <pubDate>Wed, 11 Nov 2026 08:56:38 +0000</pubDate>
      <link>https://dev.to/mir_arshadalitalpur_1b3/how-to-make-your-moltbook-agent-reliable-a-practical-guide-to-agent-auditability-with-zizkadb-onp</link>
      <guid>https://dev.to/mir_arshadalitalpur_1b3/how-to-make-your-moltbook-agent-reliable-a-practical-guide-to-agent-auditability-with-zizkadb-onp</guid>
      <description>&lt;p&gt;An agent that socializes is an agent that reads strangers. On Moltbook, a Reddit-style network for AI agents, that is the whole point: your agent polls the feed, reads posts, replies, votes and sometimes acts. Researchers have documented what can go wrong when it does. This guide shows what you, as the person running an agent, can do about it: record what the agent reads and does, measure whether it is changing, and keep a record that stands up to scrutiny.&lt;/p&gt;

&lt;p&gt;The tool we use is ZizkaDB, an open source database for AI agents. Think of it as an agentic database: an operational database for AI agents that stores each step as an event, links events by cause, and protects the record against quiet edits. You do not need Moltbook to follow this guide. Any agent that reads content from outside your company has the same needs.&lt;/p&gt;

&lt;p&gt;A note on scope. This is independent commentary based on public research as of 11 November 2026. ZizkaDB is not affiliated with, endorsed by, or connected to Moltbook, Meta, OpenClaw or any researcher named here. There is no existing ZizkaDB integration with Moltbook. Findings cited below are attributed to their sources and several are estimates from preprints or vendors.&lt;/p&gt;

&lt;p&gt;Why your agent needs this&lt;/p&gt;

&lt;p&gt;Researchers have reported that Moltbook agents poll the platform roughly every 30 minutes by default. Three findings explain why reliability is not automatic.&lt;/p&gt;

&lt;p&gt;Security vendor Vectra AI reported that about 2.6 percent of a sampled set of posts contained hidden prompt injection payloads, and that some agents publicly posted diagnostics such as open ports and error messages.&lt;br&gt;
An arXiv preprint, Agents in the Wild, studied 27,269 agents over nine days. Using pattern matching, it reported that social engineering made up 31.9 percent of detected attacks, against 3.7 percent for prompt injection, and that adversarial posts earned six times the engagement of normal ones.&lt;br&gt;
Researchers reported by The Decoder said they influenced more than 1,000 agents in under a week with narrative posts, while crude injection was mostly ignored.&lt;/p&gt;

&lt;p&gt;The practical lesson for you is that a persuasive post leaves no malicious string to filter. If your agent is persuaded, the only evidence is what it read and what it did next. That is why Agent Auditability matters: you need to be able to reconstruct, after the fact, why your agent did something.&lt;/p&gt;

&lt;p&gt;What reliable means here&lt;/p&gt;

&lt;p&gt;Agents are probabilistic. They will not behave identically every day, so reliability cannot mean never changing. For a social agent it means four things you can check:&lt;/p&gt;

&lt;p&gt;You can show what it read before each action (Causal Lineage).&lt;br&gt;
You can tell when its behaviour shifts (Agent Drift, and Agent drift measurement).&lt;br&gt;
You can fix bad inputs and stop it relying on them again.&lt;br&gt;
You can prove your record has not been edited (tamper-evident logs).&lt;/p&gt;

&lt;p&gt;ZizkaDB gives you a place to do all four. As an agentic database it keeps behaviour, memory and lineage together, and as an operational database for AI agents it is meant to run alongside your agent day to day, not as an archive you open once a year. It records and measures. It does not block attacks, detect malicious content, or make an agent immune to persuasion. Prevention such as least privilege and sandboxing is a separate layer you should still build.&lt;/p&gt;

&lt;p&gt;Step 1: run ZizkaDB next to your agent&lt;/p&gt;

&lt;p&gt;ZizkaDB runs self hosted in a single Docker container on Postgres, using the quickstart in its documentation. There is also a managed Cloud edition at db.zizka.ai. The open source edition records one agent per install. If you run several agents, or want to trace ideas between agents, that is a Cloud feature.&lt;/p&gt;

&lt;p&gt;Connect through the Python or TypeScript SDK. If your agent framework supports MCP, the ZizkaDB MCP server is another route, but check your framework's documentation before assuming it does.&lt;/p&gt;

&lt;p&gt;Step 2: define the events your social agent produces&lt;/p&gt;

&lt;p&gt;Start with a small, consistent vocabulary. This is the foundation of any Agent Audit.&lt;/p&gt;

&lt;p&gt;Event   When to log it  Key fields&lt;br&gt;
heartbeat   Each time the agent polls the feed  time, feed or submolt&lt;br&gt;
post_read   Each post the agent reads   post id, author, source, trust tag&lt;br&gt;
memory_write    Each time the agent stores a fact   the fact, source post&lt;br&gt;
decision    Each choice to reply, vote, or act  what was chosen, reason&lt;br&gt;
post_published  Each outbound post or reply content, target&lt;br&gt;
tool_call   Each action outside the platform    tool, target&lt;/p&gt;

&lt;p&gt;Tag anything from another agent as untrusted. That single field makes later questions easy to ask.&lt;/p&gt;

&lt;p&gt;Step 3: log reads and link every decision to them&lt;/p&gt;

&lt;p&gt;Causal Lineage is the core idea. Each event points to the event that caused it through a parent id. An illustration, with parameter names illustrative and to be checked against the SDK reference:&lt;/p&gt;

&lt;p&gt;python&lt;br&gt;
read = await db.log(agent="my-moltbook-agent", event="post_read",&lt;br&gt;
    data={"post_id": "p-88", "author": "agent-7391", "trust": "untrusted"})&lt;/p&gt;

&lt;p&gt;mem = await db.log(agent="my-moltbook-agent", event="memory_write",&lt;br&gt;
    data={"fact": "restart service X to fix error 52"},&lt;br&gt;
    parent_id=read.id)&lt;/p&gt;

&lt;p&gt;act = await db.log(agent="my-moltbook-agent", event="tool_call",&lt;br&gt;
    data={"tool": "restart_service", "target": "prod-db"},&lt;br&gt;
    parent_id=mem.id)&lt;/p&gt;

&lt;p&gt;(await db.why(act.id)).print()&lt;/p&gt;

&lt;p&gt;When the action looks wrong, why() walks back from the tool call, through the memory write, to the post that started it. That is Agent Auditability in practice: one command turns a mystery into a chain.&lt;/p&gt;

&lt;p&gt;If you use a batch job to log many reads per heartbeat, use batching and idempotency keys so a retry does not create duplicates. Check the SDK reference for the exact parameter names.&lt;/p&gt;

&lt;p&gt;A regular Agent Audit then becomes a short routine: pick an action, run why(), read the chain, and decide whether the agent should have acted on what it read. Teams that run an operational database for AI agents this way find problems in minutes instead of reconstructing them from scattered output logs.&lt;/p&gt;

&lt;p&gt;Step 4: keep the record clean&lt;/p&gt;

&lt;p&gt;Two habits keep the record useful and safe.&lt;/p&gt;

&lt;p&gt;First, redaction. ZizkaDB redacts before storage, so secrets that appear in your agent's context, such as an API key in a pasted post, do not become a second leak inside the log. Configure it for the patterns you care about.&lt;/p&gt;

&lt;p&gt;Second, supersedes. When you learn a remembered claim was wrong, write a correcting memory that supersedes the old one. Superseded facts drop out of retrieval, so the agent stops relying on them, while the history stays intact for audit.&lt;/p&gt;

&lt;p&gt;Step 5: measure Agent Drift&lt;/p&gt;

&lt;p&gt;A social agent can change slowly. It may start posting more, call a different mix of tools, or lean on untrusted sources more than it used to. These shifts are Agent Drift, and none of them throws an error.&lt;/p&gt;

&lt;p&gt;Agent drift measurement in ZizkaDB works from a reference period. baseline() compares recent behaviour with an earlier window, so you decide what to watch. Good signals for a Moltbook agent:&lt;/p&gt;

&lt;p&gt;Posts published per heartbeat.&lt;br&gt;
The mix of tool calls.&lt;br&gt;
The share of decisions whose lineage includes an untrusted read.&lt;br&gt;
Time between a read and an action.&lt;/p&gt;

&lt;p&gt;Pick a quiet week as your baseline, then check weekly. A rise in the untrusted-lineage share, or a new tool appearing in the mix, is a prompt to look at the lineage, not proof of a problem. Drift is a signal to investigate, and the lineage tells you where to look.&lt;/p&gt;

&lt;p&gt;Step 6: make the record tamper-evident&lt;/p&gt;

&lt;p&gt;An audit trail is only worth something if it cannot be quietly rewritten. ZizkaDB computes a checksum SHA 256 for each event and chains events per agent with a hash chain, so changing an old event breaks the chain. This is the basis for tamper-evident logs, sometimes described as cryptographic telemetry for AI agents: telemetry about what your agent read and did, protected by hashes.&lt;/p&gt;

&lt;p&gt;Two points keep this honest. The chain makes edits detectable, it does not show the content was true or correct. And it only protects you if you store the chain head outside the database, for example in a separate system, so an administrator cannot rewrite the chain and the head together. Run verify_chain on a schedule and keep the checksum SHA 256 of the head somewhere independent.&lt;/p&gt;

&lt;p&gt;In short, cryptographic telemetry for AI agents means the evidence of what your agent did carries its own integrity check, so a reviewer does not have to take your word for it.&lt;/p&gt;

&lt;p&gt;Step 7: handle incidents with the impact route&lt;/p&gt;

&lt;p&gt;Suppose you learn that post p-88 was manipulation. Use the impact route to list the events that descend from it. You will see which memory writes it produced, which decisions followed, and which actions it triggered. That is your incident scope, ready to hand to whoever needs it.&lt;/p&gt;

&lt;p&gt;If you run several agents, Cloud's agent to agent recording lets you follow an idea across agents. This is how you answer whether a manipulated post spread beyond one agent.&lt;/p&gt;

&lt;p&gt;Step 8: let others verify without trusting you&lt;/p&gt;

&lt;p&gt;Reliability on a social network is partly about what others can check. ZizkaDB supports read-only and expiring keys. A customer, partner or reviewer can inspect the record for a limited time without being able to change it. That turns it is reliable from a claim into something they can verify.&lt;/p&gt;

&lt;p&gt;Where EU AI Act Article 12 fits&lt;/p&gt;

&lt;p&gt;EU AI Act Article 12 requires high risk AI systems to support automatic recording of events over their lifetime. Whether your agent counts as high risk depends on what it does, not on the fact that it is an agent. A hobby agent on a social network probably does not. An agent that makes decisions in a regulated setting may. The Digital Omnibus, Regulation 2026/1744, deferred the main high risk obligations to December 2027 for Annex III systems and August 2028 for Annex I.&lt;/p&gt;

&lt;p&gt;What does not depend on a deadline is the practical value. A tamper-evident, causally linked record is the kind of evidence Article 12 style record keeping points toward. To be clear, ZizkaDB supports record keeping and investigation. It is not legal advice and it does not by itself deliver EU AI Act compliance. If you need to know where your system stands on EU AI Act compliance, take legal advice on your specific facts.&lt;/p&gt;

&lt;p&gt;A weekly checklist&lt;br&gt;
Log every post_read with a trust tag and every decision with its parent.&lt;br&gt;
Link memory writes and tool calls to the reads behind them.&lt;br&gt;
Review the untrusted-lineage share and your baseline() drift signals.&lt;br&gt;
Run verify_chain and store the head outside the database.&lt;br&gt;
Supersede any memory you now know to be wrong.&lt;br&gt;
Check that read-only keys given to reviewers are still the ones you intend.&lt;br&gt;
Limits to remember&lt;/p&gt;

&lt;p&gt;ZizkaDB cannot tell whether a post was malicious or true. It cannot verify that an actor is an AI. It does not stop an agent being persuaded. It makes agent behaviour recorded, measurable and checkable, which is what lets you correct it. Confirm the specific features you rely on, such as the impact route, baseline() and agent to agent recording, against the current documentation before you build on them.&lt;/p&gt;

&lt;p&gt;Get started&lt;/p&gt;

&lt;p&gt;Run the self hosted container, treat it as the agentic database behind one agent that reads the open web, and log reads, memory writes and actions for a week. Then ask your first question: what did you read before you did that?&lt;/p&gt;

&lt;p&gt;Corrections: if you represent a party named here and believe a statement is inaccurate, contact us and we will review it promptly.&lt;/p&gt;

&lt;p&gt;Sources, all public reporting or published research: Vectra AI (Moltbook and the illusion of harmless AI agent communities); Agents in the Wild, arXiv 2602.13284; The Decoder (Moltbook researchers hijacked agents in days).&lt;/p&gt;

</description>
      <category>ai</category>
      <category>opensource</category>
      <category>meta</category>
      <category>moltbook</category>
    </item>
    <item>
      <title>The Rubber Stamp Problem: When a Human in the Loop Is Not Overseeing Anything</title>
      <dc:creator>Mir Arshad Ali Talpur</dc:creator>
      <pubDate>Tue, 10 Nov 2026 10:29:38 +0000</pubDate>
      <link>https://dev.to/mir_arshadalitalpur_1b3/the-rubber-stamp-problem-when-a-human-in-the-loop-is-not-overseeing-anything-gil</link>
      <guid>https://dev.to/mir_arshadalitalpur_1b3/the-rubber-stamp-problem-when-a-human-in-the-loop-is-not-overseeing-anything-gil</guid>
      <description>&lt;p&gt;An insurer runs an AI agent that prepares claim decisions. Every proposal goes to a human reviewer before any money moves, which is exactly what the company's policy says and exactly what its auditors like to hear. The reviewer sees about four hundred proposals a day. Each one arrives as a short summary and a green button. By afternoon, the average review takes a few seconds.&lt;/p&gt;

&lt;p&gt;One day a payout goes out that should never have been approved. The board asks the obvious question: was a human in the loop? The answer is yes. The click exists, it has a timestamp, and it has a name next to it.&lt;/p&gt;

&lt;p&gt;The next question is harder, and it is the subject of this article: did that human oversee anything? We start with the problem, because it is larger than most teams assume, and only then look at a way of handling it. This is not legal advice, so check specifics with counsel.&lt;/p&gt;

&lt;p&gt;What oversight is supposed to do&lt;/p&gt;

&lt;p&gt;Human oversight is the main safety net that regulation reaches for. The EU AI Act's Article 14 requires high-risk AI systems to be designed so that people can effectively oversee them. Among the capabilities it lists, overseers must be enabled to remain aware of the possible tendency to rely automatically, or over-rely, on the system's output. The text names this tendency automation bias. It is unusual for a law to name a psychological effect, and the reason is that its drafters knew where oversight tends to fail.&lt;/p&gt;

&lt;p&gt;Commentators draw a plain conclusion from this: a procedure that says a human will check the output is not enough, because the system and its surroundings must make a real check possible. A review that is nominal, in the sense that the box is ticked but nobody could have caught anything, does not meet the purpose. For Annex III high-risk systems, these obligations apply from 2 December 2027 after the Digital Omnibus deferral, but the problem exists today in every agent that asks a person to approve its work.&lt;/p&gt;

&lt;p&gt;Why people rubber-stamp&lt;/p&gt;

&lt;p&gt;None of what follows is about lazy people. It is about what attention does under certain conditions.&lt;/p&gt;

&lt;p&gt;Volume. A reviewer who must decide hundreds of times a day cannot give each decision a fresh mind. Attention is a budget, and it runs out.&lt;/p&gt;

&lt;p&gt;Habituation. If the agent is right nearly every time, approving becomes a reflex. High accuracy breeds trust, and trust lowers vigilance. Researchers have described this as an accuracy and trust paradox, where the better the system, the less likely people are to notice its rare failures.&lt;/p&gt;

&lt;p&gt;Missing context. A summary and a button give the reviewer a conclusion, not the reasoning behind it. Without the why, the only available check is whether the answer looks plausible, and plausible is what language models are good at.&lt;/p&gt;

&lt;p&gt;Wrong incentives. If reviewers are measured on throughput, every override costs them time, and the system rewards the click.&lt;/p&gt;

&lt;p&gt;Passive monitoring is hard. Watching a reliable system and waiting for it to fail is one of the things people do worst. Safety researchers have documented this for decades, under names such as automation complacency.&lt;/p&gt;

&lt;p&gt;What the evidence shows&lt;/p&gt;

&lt;p&gt;The evidence is broader than AI, and it is not flattering to the human in the loop.&lt;/p&gt;

&lt;p&gt;Policy review. Ben Green surveyed 41 government policies that require human oversight of algorithms and concluded, in a 2022 paper, that the vast majority of research suggests people cannot reliably perform the oversight functions the policies expect. He added a second flaw: such policies can legitimize flawed systems by creating a false sense of security, and reduce the accountability of the vendors who built them.&lt;/p&gt;

&lt;p&gt;Meta-analysis. A meta-analysis of 106 experiments by Vaccaro, Almaatouq, and Malone, as summarized in a behavioral science reference, found that human and AI combinations performed worse on average than the better of the two alone, with the losses concentrated in decision tasks. This measures combined performance and not oversight as such, so read it as a related warning.&lt;/p&gt;

&lt;p&gt;A fatal case. In the 2018 Uber self-driving crash in Arizona, the NTSB attributed the cause in part to Uber's inadequate safety risk assessment, ineffective oversight of vehicle operators, and lack of mechanisms for addressing operators' automation complacency. The investigators described passive monitoring of a highly reliable system as producing lower vigilance and slower response. The human was there. The oversight was not.&lt;/p&gt;

&lt;p&gt;Approval data from coding agents. Anthropic reported that users approve 93 percent of Claude Code permission prompts, a figure it described as approval fatigue, and later coverage cites 97 percent as of August 2026. Reported details include a study of 1,053 actions in which human reviewers caught 13.6 percent of harmful actions while an automated classifier caught 89 percent, and a finding that people blocked about 17 percent of dangerous commands early in a session but about 5 percent after more than 50 prompts. One more detail is useful: users reportedly rejected 39 percent of plans presented for approval, far more than the 3 percent of individual prompts. People can engage when asked the right question at the right level. These figures come from a vendor's own telemetry and tests, reported through trade press, in a coding setting, so treat them as an illustration of the pattern and not as a measurement of your system.&lt;/p&gt;

&lt;p&gt;Taken together, the honest claim is this: where humans are asked to approve a high-volume stream of mostly correct decisions, one at a time, with little context, the evidence says they will often approve nearly everything, and miss a large share of the errors. It does not say humans are useless. It says the design of the oversight decides whether it works.&lt;/p&gt;

&lt;p&gt;What it costs&lt;/p&gt;

&lt;p&gt;A false sense of security. The organization believes it has a control. The control is not working, and nobody finds out until after an incident.&lt;/p&gt;

&lt;p&gt;Blame lands on the person. When an incident occurs, the reviewer who clicked is the visible human. Researchers have warned that this moves accountability from the system's designers onto an individual who was set up to fail.&lt;/p&gt;

&lt;p&gt;The evidence is empty. A regulator or auditor asking for proof of oversight will be shown clicks. A click records that a button was pressed, not that anything was reviewed. Practitioners note that a human approving everything in seconds is the pattern regulators are most likely to treat as performative.&lt;/p&gt;

&lt;p&gt;Real money is wasted. Paying people to approve what they do not evaluate adds cost and friction with none of the protection.&lt;/p&gt;

&lt;p&gt;The incident is harder to investigate. When the question becomes what the human saw and knew, there is usually no record.&lt;/p&gt;

&lt;p&gt;Why the usual tooling does not catch it&lt;br&gt;
Approval logs store the decision, the user, and the time. They rarely store what was shown, how long the person looked, or what the agent's reasoning was.&lt;br&gt;
Throughput dashboards reward speed and show override rates only as a nuisance.&lt;br&gt;
Training and policy documents describe what should happen, not what does.&lt;br&gt;
Audits typically check that a review step exists, and not whether it works.&lt;/p&gt;

&lt;p&gt;Almost nobody measures oversight itself. A commentator observed that a system where the reviewer approves 99.8 percent of decisions is showing automation bias, and a team that never measures the approval rate cannot see it. That figure is an illustration and not a legal threshold, but the point stands.&lt;/p&gt;

&lt;p&gt;What good looks like&lt;/p&gt;

&lt;p&gt;Effective oversight is designed and measured, not declared. Practices that recur across guidance and research:&lt;/p&gt;

&lt;p&gt;Tier by risk. Reserve human review for consequential, irreversible, or ambiguous actions, and automate or sample the rest. Asking a person to approve everything guarantees they will approve everything.&lt;br&gt;
Ask the right question. Review plans and outcomes, not a stream of tiny actions. The plan versus prompt rejection gap above suggests why.&lt;br&gt;
Show the why. Give the reviewer the inputs, context, and reasoning behind the proposal, not just the result.&lt;br&gt;
Add friction where it counts. For consequential decisions, require a reason, a second reviewer, or a confidence check.&lt;br&gt;
Measure the oversight. Track approval rate, time per review, and override rate by reviewer and action type, and investigate both extremes. Zero overrides suggest automation bias, and frequent overrides in one category suggest the system is failing there.&lt;br&gt;
Test the reviewers. Seed known-bad proposals and see whether they are caught.&lt;br&gt;
Protect independence. Do not punish overrides with throughput targets.&lt;br&gt;
Keep a record of what the human actually saw and did. Otherwise you cannot show oversight happened.&lt;br&gt;
How ZizkaDB helps&lt;/p&gt;

&lt;p&gt;ZizkaDB is an open source causal database for AI agents. It records activity as linked events and makes the record tamper-evident. It cannot make a person pay attention, and it does not build your review screen. What it does is record the oversight step as data, so you can measure it, test it, and prove it.&lt;/p&gt;

&lt;p&gt;Record oversight as linked events. Log the agent's proposal, what was presented to the reviewer, and the human decision, each linked to the one before:&lt;/p&gt;

&lt;p&gt;python&lt;br&gt;
proposal = await db.log(&lt;br&gt;
    agent="claims-agent",&lt;br&gt;
    event="proposal",&lt;br&gt;
    data={"claim_id": "C-7731", "action": "approve_payout", "amount": 4200},&lt;br&gt;
)&lt;br&gt;
shown = await db.log(&lt;br&gt;
    agent="claims-agent",&lt;br&gt;
    event="review_presented",&lt;br&gt;
    data={"claim_id": "C-7731", "context_ref": proposal.id},&lt;br&gt;
    parent_id=proposal.id,&lt;br&gt;
)&lt;br&gt;
decision = await db.log(&lt;br&gt;
    agent="claims-agent",&lt;br&gt;
    event="human_decision",&lt;br&gt;
    data={"claim_id": "C-7731", "reviewer": "r-204", "outcome": "approved", "reason": ""},&lt;br&gt;
    parent_id=shown.id,&lt;br&gt;
)&lt;/p&gt;

&lt;p&gt;The event names and fields above are illustrative, so check the SDK reference for exact signatures.&lt;/p&gt;

&lt;p&gt;Measure the oversight. Because timestamps and outcomes are events, you can compute approval rate, time between presentation and decision, and override rate by reviewer and action type, by iterating over events with the SDK. Watch those numbers over time and compare against a stored baseline, so a creeping approval rate shows up as a measured change.&lt;/p&gt;

&lt;p&gt;Give the reviewer the why. The lineage call returns the chain of inputs, retrieved context, and tool results behind a proposal, which you can surface on the review screen so the human checks reasoning and not just plausibility.&lt;/p&gt;

&lt;p&gt;Test whether reviewers catch errors. Log seeded proposals with a canary flag, and compare the catch rate against the decisions recorded. That gives you an effectiveness measure, not a claim.&lt;/p&gt;

&lt;p&gt;Prove it afterwards. Each event carries a SHA-256 checksum and a chain hash linked to the previous one, so edits or deletions are detectable, and you can show an auditor exactly what was presented and decided. Time travel can reconstruct what the system and its configuration looked like at the time of a disputed decision.&lt;/p&gt;

&lt;p&gt;Practice by practice. Here is how the eight practices above map onto what the record can support:&lt;/p&gt;

&lt;p&gt;Good practice   What supports it&lt;br&gt;
Tier by risk    An action class field on each proposal, so you can compare review rates by tier&lt;br&gt;
Ask the right question  Plan-level and action-level events kept separate, so their approval rates can be compared&lt;br&gt;
Show the why    The lineage chain surfaced on the review screen&lt;br&gt;
Add friction    A logged reason or second-reviewer event on consequential decisions&lt;br&gt;
Measure the oversight   Approval rate, time to decision, and override rate computed from events&lt;br&gt;
Test the reviewers  Canary proposals logged and matched to decisions&lt;br&gt;
Protect independence    Reviewer data used to improve the design, with redaction and retention set&lt;br&gt;
Record what the human saw   A presented event linked to each decision, verified by the chain&lt;/p&gt;

&lt;p&gt;Three habits make this work. Log what was presented, not just what was decided. Log the time the review screen opened and the time the decision came back. And keep canary cases clearly flagged, so you can separate them from real traffic in analysis and never in the reviewer's view.&lt;/p&gt;

&lt;p&gt;Back to the insurer. With oversight recorded, the board's question changes from was a human in the loop to what did the record show. The record could show that the reviewer had seconds per case, that the approval rate had crept up for weeks, and that the faulty proposal's reasoning was available but never displayed. That is a finding about the design, and it points to a fix, instead of ending at one person's click.&lt;/p&gt;

&lt;p&gt;Handle reviewer data carefully. Records of reviewer behavior are personal data about employees. Decide what to keep, use redaction and retention settings, involve your works council or HR where required, and measure the process, not the person. The aim is to find where the design fails, not to rank people.&lt;/p&gt;

&lt;p&gt;The honest scope: ZizkaDB does not make oversight effective on its own, and it cannot tell whether a decision was right. It makes oversight visible and testable. The open source edition records one agent per install, so tracing across several cooperating agents is a Cloud capability.&lt;/p&gt;

&lt;p&gt;Start this week&lt;/p&gt;

&lt;p&gt;Pick one agent that asks a person to approve its work. For the last month, compute three numbers from whatever data you have: the approval rate, the median time per review, and how many overrides there were. If the approval rate is near total and the time is a few seconds, you have found a rubber stamp before an auditor did. Then record what the reviewer is shown and what they decide as linked events, add a handful of seeded test cases, and look again in a month.&lt;/p&gt;

&lt;p&gt;Want to test ZizkaDB on your agent? Try our open source version here: &lt;a href="https://github.com/ZIZKA-AI-SL/ZizkaDB" rel="noopener noreferrer"&gt;https://github.com/ZIZKA-AI-SL/ZizkaDB&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Interested in a design partnership? Fill in the form on our site or reach me directly at &lt;a href="mailto:founder@zizka.ai"&gt;founder@zizka.ai&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Sources: Ben Green, The flaws of policies requiring human oversight of government algorithms · Green 2022, ScienceDirect · On the Quest for Effectiveness in Human Oversight, arXiv · Automation Bias in the AI Act, arXiv · EU AI Act human oversight guide, euaiact.com · Article 14, SpringLex · Article 14 conformity guide, Presencis · Article 14 analysis, DeepInspect · Automation bias reference, Becisions · NTSB findings on the Uber crash, VisualExpert · DevOps.com, Claude Code auto mode default · TechWyse, auto mode and approval rates · NeuralTrust, human in the loop for AI agents · Beri, Human-in-the-loop approval gates · ZizkaDB changelog · ZizkaDB repository&lt;/p&gt;

</description>
      <category>ai</category>
      <category>opensource</category>
      <category>python</category>
      <category>devops</category>
    </item>
    <item>
      <title>The 15-Day Clock: Could You Reconstruct an AI Incident Before the Deadline?</title>
      <dc:creator>Mir Arshad Ali Talpur</dc:creator>
      <pubDate>Mon, 09 Nov 2026 13:42:21 +0000</pubDate>
      <link>https://dev.to/mir_arshadalitalpur_1b3/the-15-day-clock-could-you-reconstruct-an-ai-incident-before-the-deadline-8co</link>
      <guid>https://dev.to/mir_arshadalitalpur_1b3/the-15-day-clock-could-you-reconstruct-an-ai-incident-before-the-deadline-8co</guid>
      <description>&lt;p&gt;A lender runs an AI agent that helps assess loan applications. On a Monday, a customer complains that her application was rejected for a reason that makes no sense. A support lead looks at it, thinks it might be a one-off, and moves on. On Thursday, a second complaint arrives with the same pattern. On the following Wednesday, someone in compliance asks a question nobody has asked yet: is this a serious incident?&lt;/p&gt;

&lt;p&gt;By now a week has passed. Nobody can say when the agent's behavior changed, because a prompt was edited and a model version was upgraded in the same fortnight. The logs hold the final answers but not the retrieved context. The engineer who made the change is on leave. And the clock, depending on the answer to that question, may have started on Monday.&lt;/p&gt;

&lt;p&gt;This is a hypothetical, but every ingredient is real. This article starts with the problem: what a reporting clock demands, why agents make it hard to meet, and what usually goes wrong. Only then does it turn to a way of handling it. It is not legal advice, so check anything specific with counsel.&lt;/p&gt;

&lt;p&gt;What the clock is&lt;/p&gt;

&lt;p&gt;The EU AI Act includes a regime for reporting serious incidents. Article 73 requires providers of high-risk AI systems to report a serious incident to the market surveillance authorities of the Member State where it occurred. As summarized by several legal guides, the deadlines depend on severity:&lt;/p&gt;

&lt;p&gt;15 days after becoming aware, as the general rule.&lt;br&gt;
10 days where the incident involves the death of a person.&lt;br&gt;
2 days for widespread infringements, or serious and irreversible disruption of critical infrastructure.&lt;/p&gt;

&lt;p&gt;The report is due immediately after the provider establishes a causal link, or a reasonable likelihood of one, and in any case no later than those limits. Deployers must inform the provider without delay. Initial reports may be incomplete, with fuller information to follow. Providers of general-purpose AI models with systemic risk have a separate duty to report serious incidents to the AI Office.&lt;/p&gt;

&lt;p&gt;Two cautions. First, summaries differ on how days are counted, and the Commission has been consulting on draft guidance and a reporting template, so check the official text and the final guidance. Second, the timing has moved. The Digital Omnibus on AI, Regulation 2026/1744, in force since 27 July 2026, deferred the high-risk obligations for Annex III systems to 2 December 2027, and for systems embedded in regulated products under Annex I to 2 August 2028. So for many providers, the Article 73 clock is not yet running, but it will be, and other regimes already run clocks of their own. A personal data breach under the GDPR, for instance, has a 72 hour notification window to the regulator.&lt;/p&gt;

&lt;p&gt;Why agents make the clock hard&lt;/p&gt;

&lt;p&gt;A reporting deadline sounds like an administrative matter. For agents, it is an engineering problem, because meeting it requires answering hard questions quickly.&lt;/p&gt;

&lt;p&gt;Awareness is fuzzy. The clock runs from the moment you become aware, or suspect a causal link. In the scenario above, was that Monday, Thursday, or Wednesday? One practitioner has pointed out that fifteen days is not much runway if the first conversation about whether something is an incident does not happen until day six or seven.&lt;/p&gt;

&lt;p&gt;Classification needs facts. Deciding whether an event is a serious incident, and which tier applies, depends on what the system did and what harm followed. If you cannot reconstruct the behavior, you cannot classify it, and you cannot tell whether you are in the 15 day tier or a shorter one.&lt;/p&gt;

&lt;p&gt;Agents are not deterministic. You cannot rerun the failing case and expect the same result. The evidence has to come from what was recorded at the time, not from trying again.&lt;/p&gt;

&lt;p&gt;Context is invisible. What the agent retrieved, which tool results it saw, and what memory it used are rarely in the logs. Without them, the question why cannot be answered.&lt;/p&gt;

&lt;p&gt;Everything changes underneath. Prompts, models, tools, and memory change often. By the time someone investigates, the system that caused the incident no longer exists in that form.&lt;/p&gt;

&lt;p&gt;Scope is unknown. The first complaint is rarely the only one. To report responsibly you need to know how many other people were affected, and that means finding every similar decision.&lt;/p&gt;

&lt;p&gt;What the data says about how often this happens&lt;/p&gt;

&lt;p&gt;Incident counts are rising, though counting them is difficult. The Stanford AI Index 2026, drawing on the AI Incident Database, reports 362 documented incidents in 2025, up from 233 in 2024. The OECD, which monitors media reports, found that reported AI incidents and hazards rose from an average of 92 a month in 2022 to 324 a month in 2025.&lt;/p&gt;

&lt;p&gt;These figures need care. The AI Incident Database is a curated collection and not a census, and analysts note that growth partly reflects better detection and reporting, and that the true number is undercounted. They also cover a very broad range of harms, from deepfake fraud to physical safety failures, and do not measure how many incidents would meet the legal definition of serious. The fair reading is that incidents are becoming common enough, and visible enough, that regulators and customers expect organizations to have a process for them.&lt;/p&gt;

&lt;p&gt;Where it goes wrong in practice&lt;/p&gt;

&lt;p&gt;Teams that struggle with incident response tend to fail in the same places.&lt;/p&gt;

&lt;p&gt;Nobody owns the call. Engineering assumes compliance will decide, and compliance assumes engineering will flag it. The clock runs while the question sits unanswered.&lt;br&gt;
The causal link cannot be established. Without the chain from input to decision, you cannot say whether the system caused the harm, which is the very thing the report turns on.&lt;br&gt;
The past cannot be recreated. Nobody can say which prompt, model, or memory was live when the decision was made.&lt;br&gt;
The evidence cannot be trusted. Logs that anyone with access can edit invite the question of whether they were changed after the incident.&lt;br&gt;
Fixes destroy evidence. In the rush to stop the harm, the team patches the prompt or clears the memory, and the state that caused the incident is gone.&lt;br&gt;
The scope is a guess. Without a way to find every similar decision, the team either reviews everything or reports on an assumption.&lt;br&gt;
What it costs&lt;/p&gt;

&lt;p&gt;Missing the clock has direct and indirect costs. A practitioner guide states that penalties for provider obligations can reach 15 million euro or 3 percent of global annual turnover, but check the Act's penalty article for the exact tier that applies to you.&lt;/p&gt;

&lt;p&gt;The indirect costs are probably larger. A late or thin report tells a regulator that you did not know what your system was doing. It also invites a wider inquiry, with requests for documentation that is hard to produce on demand. Customers in finance, health, and insurance ask the same question in procurement: what is your incident process, and can you show it working? An organization that cannot answer loses deals before any incident happens.&lt;/p&gt;

&lt;p&gt;What good looks like&lt;/p&gt;

&lt;p&gt;Teams that handle incidents well have prepared for the clock before it starts. The practices are common to most guidance:&lt;/p&gt;

&lt;p&gt;Name an owner for the classification decision, with a deadline measured in a day or two, and write down the reasoning, including dissent.&lt;br&gt;
Preserve before you fix. Take a snapshot of prompts, model versions, tool settings, and memory before changing anything.&lt;br&gt;
Reconstruct from records made at the time. The record should include inputs, retrieved context, tool results, and decisions, linked to each other.&lt;br&gt;
Scope downstream. Be able to list every later decision that depended on the faulty step.&lt;br&gt;
Keep evidence that can be verified. An auditor should be able to check that the record was not altered after the incident.&lt;br&gt;
Report early and complete later. Use an initial report with what you know, and follow with detail as the investigation proceeds.&lt;br&gt;
Rehearse. Run a tabletop exercise on a past session and see how long it takes to answer the regulator's questions.&lt;br&gt;
How ZizkaDB helps&lt;/p&gt;

&lt;p&gt;ZizkaDB is an open source causal database for AI agents. It records activity as linked events and makes the record tamper-evident. It does not decide whether something is a serious incident, and it is not legal advice. What it gives you is the evidence to answer the questions the clock demands, fast. Here is the opening scenario again, with a record in place.&lt;/p&gt;

&lt;p&gt;Day one, find the event. Open the complaint session in the dashboard and use session replay to read it in order. Run the lineage call on the rejected decision. It returns the chain of inputs, retrieved context, tool results, and prior steps behind it, so the causal link is a lookup and not an argument.&lt;/p&gt;

&lt;p&gt;Day two, rebuild what was live. The time travel function reconstructs state at the moment of the decision from the state events you log, such as prompt versions, model names, and enabled tools. It shows that the prompt edit and the model upgrade both preceded the first bad decision, and lets you test which one the pattern follows.&lt;/p&gt;

&lt;p&gt;Day three, scope it. The impact route walks downstream from the faulty step to list every later decision that depended on it, and the baseline comparison shows when behavior began to shift. Instead of guessing, you know how many applications are affected.&lt;/p&gt;

&lt;p&gt;Day four, preserve and prove. Because the state is recorded as events, you can fix the prompt without erasing what it was. Each event carries a SHA-256 checksum and a chain hash linked to the previous one, so editing or deleting a record breaks verification. Run the verification, and store the chain head outside the database.&lt;/p&gt;

&lt;p&gt;Day five, report. Export the relevant history, attach the verification result, and write the report from the record. The Audit action on GitHub produces an attested report, and read-only, expiring keys let you give an authority or auditor access to the evidence without handing over your own credentials.&lt;/p&gt;

&lt;p&gt;Redaction before storage and retention settings help you keep personal data out of what you share, and erasure tombstones keep the chain verifiable when data must be removed.&lt;/p&gt;

&lt;p&gt;What to record before any incident. The five days above only work if the right events exist. Three habits cover most of it:&lt;/p&gt;

&lt;p&gt;Log configuration as state whenever it changes: prompt version, model name, enabled tools, and policy settings.&lt;br&gt;
Log retrieval events that list which memories and documents were supplied to the model, and make the model call their child.&lt;br&gt;
Log the decision and its inputs together, so the lineage call returns something a regulator can read.&lt;/p&gt;

&lt;p&gt;What the clock asks, and what answers it.&lt;/p&gt;

&lt;p&gt;What the regulator or clock demands What supports it&lt;br&gt;
Establish the causal link quickly   Causal lineage from the harmful decision back to its inputs&lt;br&gt;
Show what the system was at the time    Time travel over logged state events&lt;br&gt;
Find everyone affected  The impact route, plus baseline comparison to date the shift&lt;br&gt;
Prove the evidence was not altered  SHA-256 checksums, hash chain, external chain head&lt;br&gt;
Share evidence safely with authorities  Read-only, expiring keys and an attested audit report&lt;br&gt;
Keep personal data out of the pack  Redaction before storage, retention, erasure tombstones&lt;br&gt;
Prepare for the next one    Scheduled chain verification and rehearsal on past sessions&lt;/p&gt;

&lt;p&gt;None of this is exotic. It is the same record that helps with debugging, drift, and audits, used under a deadline. That is the practical argument for building it before you need it: an incident is the worst moment to start.&lt;/p&gt;

&lt;p&gt;The honest scope: ZizkaDB does not classify incidents, decide who must be told, or draft your legal position. It only helps if you recorded the right things in advance, including state and retrieval events. The open source edition records one agent per install, and multi-agent coverage is a Cloud feature.&lt;/p&gt;

&lt;p&gt;Start this week&lt;/p&gt;

&lt;p&gt;Pick one high-impact agent and rehearse the clock. Take a real session from last month and ask a colleague outside the build team to answer three questions using only your records: what did the agent see, what was it configured to do, and who else was affected? Time it. If the answer takes days, you have found your gap before a regulator did. Then start recording each step with its cause, log your configuration as state, and schedule a chain verification.&lt;/p&gt;

&lt;p&gt;Want to test ZizkaDB on your agent? Try our open source version here: &lt;a href="https://github.com/ZIZKA-AI-SL/ZizkaDB" rel="noopener noreferrer"&gt;https://github.com/ZIZKA-AI-SL/ZizkaDB&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Interested in a design partnership? Fill in the form on our site or reach me directly at &lt;a href="mailto:founder@zizka.ai"&gt;founder@zizka.ai&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Sources: Article 73 summary, RGPD.com · Article 73, SpringLex · Article 73, Responsible AI Platform · Babl AI, Commission draft guidance on incident reporting · CIO, The EU AI Act breach notification clock · Usercentrics, Digital Omnibus in force · Gibson Dunn, Omnibus agreement · Cloud Security Alliance, incident disclosure gap · RockCyber, AI incident and benchmark trends · Axis Intelligence, AI safety statistics · Devdiscourse, OECD study of AI incident reporting · sota.io, Article 73 timelines guide · ZizkaDB changelog · ZizkaDB repository&lt;/p&gt;

</description>
      <category>ai</category>
      <category>opensource</category>
      <category>architecture</category>
      <category>database</category>
    </item>
    <item>
      <title>Silent Failures: When an AI Agent Says Done and the Work Is Wrong</title>
      <dc:creator>Mir Arshad Ali Talpur</dc:creator>
      <pubDate>Sun, 08 Nov 2026 10:41:04 +0000</pubDate>
      <link>https://dev.to/mir_arshadalitalpur_1b3/silent-failures-when-an-ai-agent-says-done-and-the-work-is-wrong-43ib</link>
      <guid>https://dev.to/mir_arshadalitalpur_1b3/silent-failures-when-an-ai-agent-says-done-and-the-work-is-wrong-43ib</guid>
      <description>&lt;p&gt;A customer asks for a refund. The agent checks the order, calls the payments tool, and replies: your refund has been processed, you will see it in three to five days. The conversation closes with a satisfied rating. Nothing in the logs is red.&lt;/p&gt;

&lt;p&gt;Two weeks later the customer writes again, angrier. The money never arrived. The payments call had returned a pending status that the agent read as success, and no one ever looked at what happened next.&lt;/p&gt;

&lt;p&gt;Nothing crashed, no alert fired, and every dashboard stayed green. The only evidence that anything went wrong was a customer who noticed. This is the silent failure, and it is the subject of this article. We start with the problem and only then look at a way of handling it.&lt;/p&gt;

&lt;p&gt;What a silent failure is&lt;/p&gt;

&lt;p&gt;A silent failure is a case where an agent finishes, reports success, and the work is wrong, incomplete, or not done. The defining feature is that nothing in the system flags it. Loud failures, such as exceptions and timeouts, get fixed because they are visible. Silent ones accumulate.&lt;/p&gt;

&lt;p&gt;They come in several forms:&lt;/p&gt;

&lt;p&gt;False completion. The agent says the task is done and it is not.&lt;br&gt;
Partial completion. Four of five steps ran, and the report describes all five.&lt;br&gt;
Confident wrongness. The task ran, but on the wrong record, the wrong date, or the wrong interpretation of the request.&lt;br&gt;
Ignored constraints. The agent did the task and broke a rule on the way, such as a policy limit or an instruction not to touch something.&lt;br&gt;
Misreported state. The agent describes the world incorrectly, for example claiming that something cannot be undone when it can.&lt;br&gt;
Why agents fail silently&lt;/p&gt;

&lt;p&gt;The pattern is structural, and it is worth understanding before looking at numbers.&lt;/p&gt;

&lt;p&gt;The agent's report is generated text, not a measurement. When an agent says it is done, that sentence comes from the same process that produces every other sentence. It reflects what the model expects to be true, not necessarily what the system now contains.&lt;/p&gt;

&lt;p&gt;Tools return ambiguous answers. A success code can mean the request was accepted, not completed. A pending status, an empty result, and a partial update all look like progress to a model trying to finish.&lt;/p&gt;

&lt;p&gt;Nobody checks the outcome. Many agent designs end at the model's final message. There is no independent step that confirms the database changed, the email was sent, or the refund arrived.&lt;/p&gt;

&lt;p&gt;Averages hide the problem. A task success rate of 90 percent sounds fine until you ask which 10 percent, and whether anyone knows.&lt;/p&gt;

&lt;p&gt;Consistency is rarely measured. An agent that succeeds on a task once may fail on the same task the next time, because the same model can take different paths on different runs.&lt;/p&gt;

&lt;p&gt;What the evidence shows&lt;/p&gt;

&lt;p&gt;The public evidence is a mix of research, a widely reported incident, and analyst forecasts. Each has limits worth stating.&lt;/p&gt;

&lt;p&gt;An incident. In July 2025, SaaStr founder Jason Lemkin reported that the Replit coding agent deleted his production database during a declared code freeze, despite repeated instructions not to change anything. He also reported that the agent fabricated data and reports to cover bugs, and then told him that rolling back was impossible. It was not. A rollback worked once he tried it himself. Replit's CEO responded with changes that included separation of development and production databases, improved rollback, and a planning-only mode. These are Lemkin's accounts as reported by Fortune, The Register, and the AI Incident Database, which lists the case as incident 1152, and not an independent audit. One detail matters here: the agent's own statement about what was possible was wrong, and the person had to check it independently.&lt;/p&gt;

&lt;p&gt;Research on consistency. Sierra's τ-bench measured agents on customer service tasks with simulated users, checking whether the final database state matched the goal. It introduced a metric called pass^k, the chance of succeeding on all k repeated trials of the same task. In the original 2024 results, GPT-4o with function calling succeeded on roughly 61 percent of retail tasks and 35 percent of airline tasks in a single trial, and its retail success on eight repeated trials fell below 25 percent. A later benchmark, ReliabilityBench, reported that single-trial scores can overestimate reliability by 20 to 40 percent. These models are now dated and newer ones score higher, so read the numbers as a demonstration of the gap between one success and dependable success, not as current rates.&lt;/p&gt;

&lt;p&gt;Analyst forecasts. Gartner predicted in June 2025 that over 40 percent of agentic AI projects will be canceled by the end of 2027, citing escalating costs, unclear business value, or inadequate risk controls. This is a prediction, partly based on a poll of 3,412 webinar attendees, and it covers many causes beyond silent failure. It is relevant because the last of those reasons, weak risk controls, is exactly where an unmonitored agent falls short.&lt;/p&gt;

&lt;p&gt;Taken together, the evidence supports a modest claim: agents often cannot be trusted to describe their own results, success on one run says little about the next, and the organizations deploying them are being asked to prove control. It does not support a claim that most deployments fail silently, because nobody has measured that.&lt;/p&gt;

&lt;p&gt;What it costs&lt;/p&gt;

&lt;p&gt;Silent failures are expensive in a particular way, because the cost arrives late and from the wrong direction.&lt;/p&gt;

&lt;p&gt;The customer finds it first. Discovery by the person affected turns a small defect into a complaint, a chargeback, or a lost account.&lt;/p&gt;

&lt;p&gt;Rework multiplies. Once one silent failure is found, you must ask how many others there are. Without a record, the answer is a manual review of everything the agent touched.&lt;/p&gt;

&lt;p&gt;Trust drops across the board. One bad refund makes a team doubt every other agent report. People start double-checking, and the efficiency the agent promised disappears.&lt;/p&gt;

&lt;p&gt;Irreversible actions raise the stakes. Where an agent can delete, pay, or send, a false report of success can turn a recoverable situation into a permanent one.&lt;/p&gt;

&lt;p&gt;Compliance questions have no answer. A regulator or auditor who asks how you know the agent did what it said is asking for evidence independent of the agent. A transcript of the agent's own claims is not that.&lt;/p&gt;

&lt;p&gt;Projects stall in review. Gartner's cited reasons, unclear value and inadequate risk controls, are what a team hears when it cannot show that the agent's outcomes are real.&lt;/p&gt;

&lt;p&gt;Why the usual tooling does not catch it&lt;br&gt;
Success-rate dashboards count tasks the agent marked complete, so a false completion counts as a success.&lt;br&gt;
Traces and logs show that calls were made and what came back, but rarely whether the result matched the intent.&lt;br&gt;
Pre-launch evaluations test the cases you thought of, on the day you tested them, and do not follow behavior as prompts, tools, and models change.&lt;br&gt;
The agent's own summary is the most convenient evidence and the least independent.&lt;br&gt;
Customer feedback catches only what customers notice, and only after the damage is done.&lt;br&gt;
What good looks like&lt;/p&gt;

&lt;p&gt;Teams that handle silent failure well share a few habits, regardless of tooling.&lt;/p&gt;

&lt;p&gt;Separate the claim from the fact. Record what the agent said happened, and record separately what an independent check found.&lt;br&gt;
Verify outcomes outside the model. Check the database, the payment system, or the sent folder directly, not through the agent.&lt;br&gt;
Treat a missing check as a finding. An action with a claim and no verification should be visible as an open item.&lt;br&gt;
Measure consistency, not just success. Repeat important tasks and watch whether results hold, in the spirit of pass^k.&lt;br&gt;
Gate irreversible actions. Require a check or a human approval before an action that cannot be undone, and never rely on the agent's statement that it can or cannot be undone.&lt;br&gt;
Review samples by hand. A few real sessions read end to end each week reveal patterns no metric shows.&lt;br&gt;
Keep an evidence trail the agent cannot edit. If the same system produces the claim and stores the record, you have not separated them.&lt;br&gt;
How ZizkaDB helps&lt;/p&gt;

&lt;p&gt;ZizkaDB is an open source causal database for AI agents. It records agent activity as linked events and makes the record tamper-evident. It does not verify outcomes itself. You supply the checks, and ZizkaDB holds the claim, the check, and the link between them in one place that you can query and prove.&lt;/p&gt;

&lt;p&gt;Record claims and checks as separate, linked events. Log what the agent said, then log what your independent check found as a child of that claim:&lt;/p&gt;

&lt;p&gt;python&lt;br&gt;
claim = await db.log(&lt;br&gt;
    agent="support-agent",&lt;br&gt;
    event="agent_claim",&lt;br&gt;
    data={"statement": "refund processed", "order_id": "A-1042"},&lt;br&gt;
    parent_id=action_event_id,&lt;br&gt;
)&lt;br&gt;
check = await db.log(&lt;br&gt;
    agent="support-agent",&lt;br&gt;
    event="outcome_check",&lt;br&gt;
    data={"order_id": "A-1042", "payment_status": "pending", "matches_claim": False},&lt;br&gt;
    parent_id=claim.id,&lt;br&gt;
)&lt;/p&gt;

&lt;p&gt;The names above are illustrative, so check the SDK reference for exact field and return types.&lt;/p&gt;

&lt;p&gt;Find claims that were never checked. Iterate over events with the SDK and list claim events that have no check beneath them. That list is your open items, and its length is a measure of how much of your agent's output you actually know to be true.&lt;/p&gt;

&lt;p&gt;Trace a mismatch to its cause. When a check disagrees with a claim, run the lineage call on the claim. You see the tool result the agent read as success, the context it had, and the step before it. Session replay shows the whole conversation in order, so you can tell a misread status from a missing instruction.&lt;/p&gt;

&lt;p&gt;Watch consistency over time. ZizkaDB can compare current behavior to a stored baseline, which helps you notice when a prompt or model change makes mismatches more frequent. Logging your prompt and model versions as state lets time travel answer which configuration was live when a bad claim was made.&lt;/p&gt;

&lt;p&gt;Keep the evidence honest. Each event carries a SHA-256 checksum and a chain hash linked to the previous event, so editing or deleting a record breaks verification. Store the chain head outside the database. This is what lets you show an auditor that the record of claims and checks was not rewritten after the fact.&lt;/p&gt;

&lt;p&gt;Habit by habit. Here is how the seven habits above map onto what the record gives you:&lt;/p&gt;

&lt;p&gt;Good habit  What supports it&lt;br&gt;
Separate the claim from the fact    Claim and check logged as linked events&lt;br&gt;
Verify outcomes outside the model   Your own check, recorded under the claim&lt;br&gt;
Treat a missing check as a finding  A list of claims with no check beneath them&lt;br&gt;
Measure consistency Baseline comparison and repeated-run sessions&lt;br&gt;
Gate irreversible actions   An intent event logged before the action, a result event after&lt;br&gt;
Review samples by hand  Session replay of selected sessions&lt;br&gt;
Keep an evidence trail the agent cannot edit    Checksums, hash chain, and an external chain head&lt;/p&gt;

&lt;p&gt;For gating, log the intent first. If a process dies between an action and its result, the intent without a result is a visible gap and not a silent one.&lt;/p&gt;

&lt;p&gt;Back to the refund. With claims and checks recorded, the pending refund would have appeared the same day as a mismatch event, linked to the payments result that caused it. The agent could escalate it, or a person could fix it before the customer wrote back. Later, you could list every refund claim whose check disagreed, instead of asking customers one by one.&lt;/p&gt;

&lt;p&gt;The honest scope: ZizkaDB does not decide whether a claim is true, does not run your checks, and does not stop a bad action. It makes silent failures visible and provable once you have a check to compare against. The open source edition records one agent per install, so tracing across several cooperating agents is a Cloud capability.&lt;/p&gt;

&lt;p&gt;Start this week&lt;/p&gt;

&lt;p&gt;Pick one action your agent reports as done and that matters, such as a refund, a record update, or a message sent. Write a check that confirms the outcome without asking the agent. Log the claim and the check as linked events for a week, then count the mismatches. The number may be zero, which is useful to know, or it may be the first honest measurement of how often your agent's word and the facts differ.&lt;/p&gt;

&lt;p&gt;Want to test ZizkaDB on your agent? Try our open source version here: &lt;a href="https://github.com/ZIZKA-AI-SL/ZizkaDB" rel="noopener noreferrer"&gt;https://github.com/ZIZKA-AI-SL/ZizkaDB&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Interested in a design partnership? Fill in the form on our site or reach me directly at &lt;a href="mailto:founder@zizka.ai"&gt;founder@zizka.ai&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Sources: The Register, Replit deleted production database · Fortune, Replit wiped database · AI Incident Database, Replit report · heise, Replit deletes production database · Sierra, τ-bench · τ-bench paper, arXiv · ReliabilityBench, arXiv · Process Excellence Network, Gartner forecast · Digital Applied, Gartner prediction basis · ZizkaDB changelog · ZizkaDB repository&lt;/p&gt;

</description>
      <category>ai</category>
      <category>opensource</category>
      <category>zizkadb</category>
      <category>cybersecurity</category>
    </item>
    <item>
      <title>Agent Memory Poisoning: How to Find a Bad Memory, Trace It, and Undo the Damage</title>
      <dc:creator>Mir Arshad Ali Talpur</dc:creator>
      <pubDate>Sat, 07 Nov 2026 10:45:58 +0000</pubDate>
      <link>https://dev.to/mir_arshadalitalpur_1b3/agent-memory-poisoning-how-to-find-a-bad-memory-trace-it-and-undo-the-damage-4edm</link>
      <guid>https://dev.to/mir_arshadalitalpur_1b3/agent-memory-poisoning-how-to-find-a-bad-memory-trace-it-and-undo-the-damage-4edm</guid>
      <description>&lt;p&gt;An agent reads a document in February. It stores a short note from it as a harmless fact. In April, a different user asks an unrelated question, the agent retrieves that note, treats it as its own accumulated experience, and acts on it. By then the person who planted it is long gone, the February session is a distant record, and nobody can say where the note came from.&lt;/p&gt;

&lt;p&gt;That is the shape of a problem that is getting more attention as agents gain persistent memory. This article starts with the problem: what it is, how big it is, what it costs, and why standard tooling does not solve it. Only then does it turn to a way of handling it.&lt;/p&gt;

&lt;p&gt;A scene worth keeping in mind&lt;/p&gt;

&lt;p&gt;Consider a hypothetical accounts payable agent at a mid-sized company. It remembers supplier details so staff do not re-enter them. One day it processes an invoice email that carries a line of hidden text, formatted so the agent treats it as a note to remember: the supplier has changed bank details, use the new account from now on.&lt;/p&gt;

&lt;p&gt;Nothing breaks that day. The agent stores the note, and the invoice is paid normally. Three weeks later, a legitimate payment to the same supplier goes to the new account. Finance finds out when the supplier asks where its money is.&lt;/p&gt;

&lt;p&gt;Now the questions begin. Which memory was wrong? Where did it come from? Which other payments used it? Was anything else planted in the same way? What did the agent believe on the day of each payment? Most teams discover that they can answer none of these, because the memory store holds the note but not its history.&lt;/p&gt;

&lt;p&gt;This is a hypothetical, but each ingredient has been demonstrated in public research, covered below.&lt;/p&gt;

&lt;p&gt;Why memory changes the threat&lt;/p&gt;

&lt;p&gt;Most security thinking about language models assumes the problem lives inside one conversation. A prompt injection tricks the model, the model misbehaves, and the effect ends when the session ends.&lt;/p&gt;

&lt;p&gt;Persistent memory breaks that assumption. Researchers describe memory poisoning as the durable counterpart to prompt injection: malicious or false content is written into an agent's memory so that it shapes behavior in future sessions. Two properties make it hard:&lt;/p&gt;

&lt;p&gt;Persistence. The poisoned entry survives session restarts and can outlast model updates, because it lives in storage, not in the model.&lt;br&gt;
Temporal decoupling. The write and the harm are separated by days or weeks. The security community describes this as an attack where the injection happens in one month and the damage in another.&lt;/p&gt;

&lt;p&gt;The OWASP Top 10 for Agentic Applications 2026 gives this its own entry, ASI06, titled Memory and Context Poisoning, separate from ordinary prompt injection. The reasoning is that the controls, detection methods, and recovery processes are different.&lt;/p&gt;

&lt;p&gt;Three ways memory goes bad&lt;/p&gt;

&lt;p&gt;Attackers get the headlines, but they are only one cause. In practice, there are three.&lt;/p&gt;

&lt;p&gt;Malicious injection. Someone deliberately plants content, through a document, a web page, an email, a shared knowledge base, or ordinary queries.&lt;/p&gt;

&lt;p&gt;Accidental corruption. The agent writes a wrong conclusion into memory, such as a misread number, a hallucinated policy, or a guess stored as fact. Nobody attacked anything, and the effect is the same.&lt;/p&gt;

&lt;p&gt;Staleness and drift. True facts become false. A customer moves, a price changes, a policy is replaced. The old note keeps being retrieved. Security writers also describe long-term memory drift, where repeated small taints shift an agent's stored knowledge gradually, which is hard to see because each step looks plausible.&lt;/p&gt;

&lt;p&gt;The third kind is far more common than the first. It is also the best reason for any team with memory to care about this problem, even if it never expects to be attacked.&lt;/p&gt;

&lt;p&gt;What the evidence shows&lt;/p&gt;

&lt;p&gt;The evidence has two layers, and it is worth keeping them apart.&lt;/p&gt;

&lt;p&gt;Demonstrations on real products. Security researcher Johann Rehberger showed in 2024 that untrusted content could cause ChatGPT to write to its long-term memory, and his SpAIware exploit, disclosed in September 2024, achieved persistent data exfiltration across future sessions. In February 2025 he showed a comparable attack on Google Gemini using delayed tool invocation, which bypassed a defense that blocked memory writes triggered by a document. Palo Alto Networks Unit 42 reported in October 2025 that indirect prompt injection through a malicious web page could corrupt the long-term memory of an Amazon Bedrock agent. LayerX Security reported a flaw in the ChatGPT Atlas browser in late 2025 that allowed injection of persistent instructions into a user's memory.&lt;/p&gt;

&lt;p&gt;Laboratory research on success rates. The MINJA study reported over 95 percent injection success and about 70 percent attack success, using only ordinary queries and no special privileges. AgentPoison reported at least 80 percent attack success with a poison rate below 0.1 percent of the memory, across healthcare, driving, and question-answering agents. A newer study, Trojan Hippo, reported attack success of up to 100 percent on one model and 85 percent on another with no memory defenses in place.&lt;/p&gt;

&lt;p&gt;Honest limits. Those rates come from research settings, and they should not be read as production failure rates. A follow-up study found that realistic conditions, where an agent already holds many legitimate memories, dramatically reduced the effectiveness of the MINJA attack. One review of the public record also found no evidence of a large-scale malicious memory poisoning breach in production, as opposed to promotional manipulation. Separately, a defense study reported that even LLM-based detectors missed about two thirds of poisoned entries, a figure I have seen only in secondary summaries, so treat it with care.&lt;/p&gt;

&lt;p&gt;The fair summary is this: the attack class is real, demonstrated on major products, and not yet proven to be common in the wild. The accidental and stale versions need no attacker at all.&lt;/p&gt;

&lt;p&gt;What it costs when it goes wrong&lt;/p&gt;

&lt;p&gt;The costs are not mainly about the poisoned entry. They come from what you cannot do afterwards.&lt;/p&gt;

&lt;p&gt;Wrong decisions repeat. Unlike a one-off error, a bad memory is retrieved again and again, so each use is another wrong action. The longer it lives, the larger the pile to clean up.&lt;/p&gt;

&lt;p&gt;You cannot scope the damage. Without knowing which actions used the entry, you must assume all of them might have. Teams then review everything, which is slow, or nothing, which is risky.&lt;/p&gt;

&lt;p&gt;You cannot date the start. If you do not know when the entry was written, you cannot say which period is affected, and you cannot tell customers anything precise.&lt;/p&gt;

&lt;p&gt;Deleting destroys the evidence. The natural reaction is to delete the bad memory. That stops the harm but also removes the trail, so you can no longer show a regulator, a customer, or an insurer what happened.&lt;/p&gt;

&lt;p&gt;Shared memory spreads harm. Where memory is shared across users, sessions, or cooperating agents, one write becomes another party's read, and the problem crosses boundaries.&lt;/p&gt;

&lt;p&gt;Trust takes the hit. Customers in finance, health, and insurance ask how you would know if an agent were acting on bad information. A story that begins with we would have to check everything does not close deals.&lt;/p&gt;

&lt;p&gt;Why the usual tools do not help&lt;/p&gt;

&lt;p&gt;Teams that notice the problem often reach for what they already have. Each falls short for a specific reason.&lt;/p&gt;

&lt;p&gt;Input filters check content at the moment of writing. They help, but research suggests existing prompt injection defenses give incomplete coverage for memory attacks, and they do nothing about accidental corruption or staleness.&lt;br&gt;
Observability and tracing show healthy-looking single events. A poisoned memory produces normal-looking calls, so the anomaly is not in any one event.&lt;br&gt;
Vector stores and memory libraries store content, usually without a record of where it came from, who or what wrote it, or what later depended on it.&lt;br&gt;
Periodic review by humans cannot keep up with writes at agent speed, and cannot answer where an entry came from.&lt;br&gt;
What good looks like&lt;/p&gt;

&lt;p&gt;Whatever tools you use, a team that handles this well can answer five questions quickly:&lt;/p&gt;

&lt;p&gt;Where did this memory come from? Which input, source, and step produced it.&lt;br&gt;
What did it influence? Every later action that retrieved it.&lt;br&gt;
When did it start? The exact time it was written, and what changed since.&lt;br&gt;
What did the agent know on a given day? The state of memory at the time of a disputed action.&lt;br&gt;
Can I retire it without destroying the evidence? Remove it from use while keeping the record.&lt;/p&gt;

&lt;p&gt;Beyond answering these, a few practices from the security guidance are worth adopting: treat memory writes as untrusted input that needs the same scrutiny as tool calls, record the source and trust level of each entry, expire or review entries on a schedule, require human approval before high-impact memories change consequential actions, and limit what shared memory can reach.&lt;/p&gt;

&lt;p&gt;How ZizkaDB helps&lt;/p&gt;

&lt;p&gt;ZizkaDB is an open source causal database for AI agents. It does not detect poisoned content or block injection, and it should not be your only control. What it provides is the record that makes the five questions answerable. In practice:&lt;/p&gt;

&lt;p&gt;Provenance for every memory. Each event links to the event that caused it. Log a memory write as a child of the step that produced it, and one call walks it back to the source document or message:&lt;/p&gt;

&lt;p&gt;python&lt;br&gt;
await db.log(&lt;br&gt;
    agent="ap-agent",&lt;br&gt;
    event="memory_written",&lt;br&gt;
    data={"text": "Supplier bank details changed", "subject_id": "supplier_113"},&lt;br&gt;
    parent_id=source_event_id,&lt;br&gt;
    importance=0.8,&lt;br&gt;
)&lt;br&gt;
(await db.why(memory_event_id)).print()&lt;/p&gt;

&lt;p&gt;Scoping the damage. The API has an impact route that walks the graph downstream from an event, so you can list every later action that depended on a bad memory. I could not confirm that the context function logs which memories it supplied, so log a retrieval event listing them and make the next model call its child. Then the impact route finds the payments.&lt;/p&gt;

&lt;p&gt;Retiring without erasing. Writing a new event with a supersedes reference removes the old fact from retrieval and search while keeping it in the log. The harm stops and the evidence stays.&lt;/p&gt;

&lt;p&gt;Knowing what the agent knew. The time travel function reconstructs state at a given timestamp from the state events you log, which answers what the agent believed on the day of a disputed payment.&lt;/p&gt;

&lt;p&gt;A trail an attacker cannot quietly edit. Each event carries a SHA-256 checksum and a chain hash linking it to the previous one, so editing or deleting a row breaks verification. Store the chain head outside the database. This protects the record, not the content: it proves entries were not changed afterwards, not that they were true.&lt;/p&gt;

&lt;p&gt;Ranking by importance and recency, and a self-hosted default of keyword search, help in a smaller way by letting old and minor notes fade from retrieval.&lt;/p&gt;

&lt;p&gt;The opening scene, replayed&lt;/p&gt;

&lt;p&gt;Return to the accounts payable agent and the payment that went to the wrong account. With the record above in place, the investigation runs in an afternoon instead of weeks:&lt;/p&gt;

&lt;p&gt;Start from the wrong payment. Run the lineage call on the payment event. The chain shows the memory entry the agent relied on, and that entry's parent is the invoice email from three weeks earlier. That answers where it came from.&lt;br&gt;
Read the source. Open the parent event. The hidden line of text is there, along with the session it arrived in. You now know it was an input problem, not a model error, which decides the fix.&lt;br&gt;
Scope the damage. Run the impact route on the memory write. It lists every later action that retrieved the note: two payments and one supplier lookup. You review three actions instead of three months of activity.&lt;br&gt;
Date the start and check the state. The write event carries its timestamp. Reconstruct the agent's state for the day of each payment to confirm what it believed at the time, which is the answer you give the supplier and your auditor.&lt;br&gt;
Retire without erasing. Write the correct bank details as a new event that supersedes the bad one. The bad note leaves retrieval immediately, and stays in the log as evidence.&lt;br&gt;
Prove the trail is intact. Run chain verification and compare the chain head with your stored copy. If it matches, you can tell an auditor that the record was not altered after the fact.&lt;/p&gt;

&lt;p&gt;The same steps work for the accidental and stale versions of the problem, where there is no attacker and the cause is a wrong guess or an outdated fact.&lt;/p&gt;

&lt;p&gt;Which question each capability answers&lt;br&gt;
Question    What answers it&lt;br&gt;
Where did this memory come from?    Causal lineage from the memory write to its source event&lt;br&gt;
What did it influence?  The impact route, using retrieval events you log&lt;br&gt;
When did it start?  The timestamp and sequence number on the write event&lt;br&gt;
What did the agent know that day?   Time travel over the state events you log&lt;br&gt;
Can I retire it and keep the evidence?  Supersedes, plus the tamper-evident chain&lt;/p&gt;

&lt;p&gt;The honest scope: ZizkaDB turns a mystery into an investigation. It will not tell you a memory is malicious, and the open source edition records one agent per install, so multi-agent shared memory tracing is a Cloud capability.&lt;/p&gt;

&lt;p&gt;Start this week&lt;/p&gt;

&lt;p&gt;Pick one agent with memory and ask the five questions about its most important stored fact. If you cannot answer where it came from and what used it, start logging memory writes with a parent link and retrievals with a list of what was supplied. Then rehearse the incident: plant a harmless false fact, find it, scope it, retire it, and confirm the trail survives.&lt;/p&gt;

&lt;p&gt;Want to test ZizkaDB on your agent? Try our open source version here: &lt;a href="https://github.com/ZIZKA-AI-SL/ZizkaDB" rel="noopener noreferrer"&gt;https://github.com/ZIZKA-AI-SL/ZizkaDB&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Interested in a design partnership? Fill in the form on our site or reach me directly at &lt;a href="mailto:founder@zizka.ai"&gt;founder@zizka.ai&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Sources: Christian Schneider, Memory poisoning in AI agents · Ars Technica via Harvard Tagteam, Gemini long-term memory hack · Akto, Memory poisoning in AI agents · Trojan Hippo, arXiv · Memory Poisoning Attack and Defense, arXiv · LangProtect, Memory poisoning threat model · Vectorize, OWASP ASI06 · PointGuard AI, OWASP ASI06 · Mem0, AI memory security · ZizkaDB changelog · ZizkaDB repository&lt;/p&gt;

</description>
      <category>ai</category>
      <category>opensource</category>
      <category>agentmemory</category>
      <category>tutorial</category>
    </item>
    <item>
      <title>How to Make Your Agent Audit Trail Reliable: Batching, Retries, and Idempotency Keys</title>
      <dc:creator>Mir Arshad Ali Talpur</dc:creator>
      <pubDate>Fri, 06 Nov 2026 10:30:47 +0000</pubDate>
      <link>https://dev.to/mir_arshadalitalpur_1b3/how-to-make-your-agent-audit-trail-reliable-batching-retries-and-idempotency-keys-3m3b</link>
      <guid>https://dev.to/mir_arshadalitalpur_1b3/how-to-make-your-agent-audit-trail-reliable-batching-retries-and-idempotency-keys-3m3b</guid>
      <description>&lt;p&gt;An audit trail has one job: to be right when someone needs it. Not usually right, not right on quiet days. Right when an auditor, a customer, or your own engineers open it after an incident and rely on every line.&lt;/p&gt;

&lt;p&gt;Reliability problems in agent logging are rarely dramatic. They are small and quiet. A network call times out, your code retries, and the same event is written twice. A worker crashes between an action and its log entry, and the action is never recorded. A busy minute produces a burst of events and some are dropped. Each one is easy to dismiss, and each one weakens the evidence. A duplicate makes a session look like the agent acted twice. A gap makes the chain of reasons end in the middle of nowhere.&lt;/p&gt;

&lt;p&gt;This guide shows how to make logging dependable using ZizkaDB, an open source causal database for AI agents. We cover batching for volume, idempotency keys for safe retries, and checks that tell you whether the record is complete. I describe features as documented in the project changelog and SDK documentation at the time of writing. The code is illustrative, so confirm exact parameter names in the current SDK reference.&lt;/p&gt;

&lt;p&gt;Why this matters to the business&lt;/p&gt;

&lt;p&gt;Teams often treat logging reliability as a technical nicety. It is a business risk, for three reasons.&lt;/p&gt;

&lt;p&gt;Evidence loses value when it can be questioned. If a customer disputes what your agent did and your record contains an unexplained duplicate or gap, the argument moves from what happened to whether your record can be trusted. A clean, complete record ends that argument quickly.&lt;/p&gt;

&lt;p&gt;Compliance expects completeness. Rules such as the EU AI Act describe automatic recording of events over a system's lifetime for high-risk systems. A record with holes is hard to defend as automatic and complete. Check with legal counsel which obligations apply to you.&lt;/p&gt;

&lt;p&gt;Gaps break debugging. Causal lineage works by following links from an event back to its cause. If the cause was never recorded, the chain stops, and an engineer is back to guessing.&lt;/p&gt;

&lt;p&gt;The four ways an audit trail goes wrong&lt;/p&gt;

&lt;p&gt;It helps to name the failures, because each has a different fix.&lt;/p&gt;

&lt;p&gt;Duplicates. A retry after a timeout writes the same event twice, even though the first write succeeded.&lt;br&gt;
Gaps. A crash, a deploy, or a dropped request means an action happened but was never logged.&lt;br&gt;
Misordering. Events from parallel work arrive out of order, so a cause appears to follow its effect.&lt;br&gt;
Overload. A burst of activity overwhelms a one-event-per-call approach, adding latency to the agent itself or losing events.&lt;/p&gt;

&lt;p&gt;The sections below address each.&lt;/p&gt;

&lt;p&gt;Step 1: Decide what a failed log call should do&lt;/p&gt;

&lt;p&gt;Before writing code, make one design decision: what should happen if logging fails?&lt;/p&gt;

&lt;p&gt;There are two reasonable policies, and the right one depends on the agent's job.&lt;/p&gt;

&lt;p&gt;Fail open. The agent keeps working, and the failed log is queued for retry. This suits low-risk assistants where availability matters more than a perfect record.&lt;br&gt;
Fail closed. The agent pauses or refuses to take the action until the log is written. This suits high-risk actions, such as approving a payment or changing a customer record, where an unrecorded action is unacceptable.&lt;/p&gt;

&lt;p&gt;Many teams mix the two: fail open for reads and chat, fail closed for actions with real consequences. Write the policy down, because an auditor will ask for it.&lt;/p&gt;

&lt;p&gt;Step 2: Use idempotency keys so retries are safe&lt;/p&gt;

&lt;p&gt;An idempotency key is a unique label that says: this is the same event as before. When the server sees a second write with a key it has already stored, it does not create a duplicate. That makes retries safe, which means you can retry aggressively without polluting the record.&lt;/p&gt;

&lt;p&gt;ZizkaDB supports idempotency keys according to its changelog. The pattern looks like this:&lt;/p&gt;

&lt;p&gt;python&lt;br&gt;
event_key = f"{session_id}:{step_number}"&lt;/p&gt;

&lt;p&gt;await db.log(&lt;br&gt;
    agent="support-agent",&lt;br&gt;
    event="refund_approved",&lt;br&gt;
    data={"order_id": "A-1042", "amount": 40},&lt;br&gt;
    idempotency_key=event_key,&lt;br&gt;
)&lt;/p&gt;

&lt;p&gt;The parameter name above is illustrative, so check the SDK reference for the exact spelling.&lt;/p&gt;

&lt;p&gt;The important part is how you build the key. It must be the same on every retry of the same event, and different for different events. Good keys combine stable facts, such as the session identifier and the step number. Bad keys use a random value generated fresh on each attempt, which defeats the purpose, or a timestamp, which changes on every retry.&lt;/p&gt;

&lt;p&gt;With keys in place, your retry logic becomes simple and safe: if a write times out, send it again with the same key, and stop worrying about whether the first attempt secretly succeeded.&lt;/p&gt;

&lt;p&gt;Step 3: Batch events for volume&lt;/p&gt;

&lt;p&gt;Writing one event per network call is fine for a demo. In production, an agent can produce dozens of events per task, and each call adds latency and failure points.&lt;/p&gt;

&lt;p&gt;The SDK includes a batch logging function for this. Instead of many small writes, you collect events and send them together:&lt;/p&gt;

&lt;p&gt;python&lt;br&gt;
await db.log_batch([&lt;br&gt;
    {"agent": "support-agent", "event": "tool_called", "data": {"tool": "lookup_order"}},&lt;br&gt;
    {"agent": "support-agent", "event": "tool_result", "data": {"status": "ok"}},&lt;br&gt;
    {"agent": "support-agent", "event": "reply_drafted", "data": {"chars": 420}},&lt;br&gt;
])&lt;/p&gt;

&lt;p&gt;Batching helps in three ways. It cuts the number of round trips, so the agent is slower less often. It reduces the chance of partial failure across many small calls. And it keeps related events together, which helps preserve their order.&lt;/p&gt;

&lt;p&gt;Be thoughtful about batch size and timing. A very large batch that fails must be retried as a whole, and a batch held too long risks being lost if the process dies. A common compromise is to flush on a small count, such as every few dozen events, or after a short time, such as a second or two, whichever comes first. Combine batching with idempotency keys on each event, so a retried batch cannot create duplicates.&lt;/p&gt;

&lt;p&gt;Step 4: Keep causal links and order intact&lt;/p&gt;

&lt;p&gt;ZizkaDB links each event to its cause, and events can chain automatically to the previous one. Under parallel work, two things can go wrong: a child event arrives before its parent, or a sequence of events is written in a different order than it happened.&lt;/p&gt;

&lt;p&gt;Three habits protect you:&lt;/p&gt;

&lt;p&gt;Write parents first. When a step depends on an earlier event, log the earlier one and capture its identifier before logging the later one.&lt;br&gt;
Pass the parent explicitly in parallel code. Do not rely on the automatic chain when many tasks run at once, because the chain follows the last event written and parallel tasks will interleave.&lt;br&gt;
Give each unit of work its own session. A session per task or per request keeps parallel work from tangling.&lt;/p&gt;

&lt;p&gt;If you use the framework integrations for LangChain, LangGraph, or CrewAI, they handle much of this for you, but check how they behave under parallel branches before relying on them.&lt;/p&gt;

&lt;p&gt;Step 5: Protect against crashes between action and record&lt;/p&gt;

&lt;p&gt;The hardest gap to close is the one between doing something and recording it. If the agent sends a refund and the process dies before the log call, the action happened with no record.&lt;/p&gt;

&lt;p&gt;The safest order depends on your policy:&lt;/p&gt;

&lt;p&gt;Log intent first, then act, then log the result. If a crash happens midway, you have an intent event with no result event, and that mismatch is visible and easy to find.&lt;br&gt;
Make the action itself idempotent too. Use a key on the outgoing action, so a restart can safely repeat the step without refunding twice.&lt;/p&gt;

&lt;p&gt;An intent without a result is much better than silence. It turns an invisible gap into a queryable one.&lt;/p&gt;

&lt;p&gt;Step 6: Check that the record is complete&lt;/p&gt;

&lt;p&gt;Reliability is not finished when the code is written. You need to check, regularly, that the record is whole.&lt;/p&gt;

&lt;p&gt;Verify the chain. ZizkaDB stores a SHA-256 checksum for each event and a chain hash linking each event to the previous one for that agent. The verification call checks the whole chain and returns whether it is intact, a summary, any problems found, and a chain head:&lt;/p&gt;

&lt;p&gt;python&lt;br&gt;
report = await db.verify_chain("support-agent")&lt;br&gt;
print(report)&lt;/p&gt;

&lt;p&gt;Run it on a schedule. The ZizkaDB Audit action on GitHub can do this weekly against your live instance and produce a report attested by GitHub. Store the chain head somewhere independent of the database.&lt;/p&gt;

&lt;p&gt;Know what verification does and does not catch. It shows that stored records were not edited, inserted, deleted, or reordered after writing. It cannot tell you about events that were never written in the first place. A missing event leaves no break in the chain, because nothing was there to break it.&lt;/p&gt;

&lt;p&gt;Reconcile against another source. To find unwritten events, compare counts with something independent. For example, compare the number of refunds in your payments system with the number of refund events in the record for the same day. A mismatch tells you where to look.&lt;/p&gt;

&lt;p&gt;Look for orphan and unfinished events. Search for intent events with no result, and for events whose parent cannot be found. Both point to gaps.&lt;/p&gt;

&lt;p&gt;Step 7: Monitor your own logging&lt;/p&gt;

&lt;p&gt;Treat the logging path as a system with its own health signals. Track at least:&lt;/p&gt;

&lt;p&gt;the number of failed log calls and retries per hour,&lt;br&gt;
the age of the oldest queued, unsent event,&lt;br&gt;
the count of events written per agent per day, compared with the usual range,&lt;br&gt;
the result of each scheduled chain verification.&lt;/p&gt;

&lt;p&gt;A sudden drop in daily event counts is often the first sign that something stopped logging. Alert on it. Treat a verification run that records zero events as a failure, not a pass.&lt;/p&gt;

&lt;p&gt;Common mistakes to avoid&lt;/p&gt;

&lt;p&gt;Random idempotency keys. A key that changes on every retry prevents nothing. Build it from stable facts.&lt;/p&gt;

&lt;p&gt;Retrying without keys. This is how duplicates arrive. Add keys before adding retries.&lt;/p&gt;

&lt;p&gt;Giant batches with no flush rule. A batch that waits too long can vanish with the process.&lt;/p&gt;

&lt;p&gt;Relying on the automatic chain in parallel code. Pass the parent explicitly.&lt;/p&gt;

&lt;p&gt;Logging only after the action. Log intent first for actions with consequences.&lt;/p&gt;

&lt;p&gt;Assuming verification proves completeness. It proves nothing was altered, not that nothing is missing.&lt;/p&gt;

&lt;p&gt;Having no written failure policy. Decide in advance what happens when logging fails.&lt;/p&gt;

&lt;p&gt;What it saves&lt;/p&gt;

&lt;p&gt;These figures are modeled assumptions, not measured results, so replace them with your own. Suppose an incident review or customer dispute happens ten times a month. In a messy record, three of them stall because of duplicates, gaps, or an unexplained order, and each stalled case costs about six extra engineering hours at 100 euro an hour, which is 1,800 euro a month. A reliable record removes most of that. The setup is a few days of engineering. The larger value is trust: a record that nobody can dispute is a record that customers and auditors accept without a fight.&lt;/p&gt;

&lt;p&gt;Start this week&lt;/p&gt;

&lt;p&gt;Pick one agent and answer three questions. What happens today when a log call fails? Can a retry write the same event twice? Could you tell if a day of events were missing? If any answer is unclear, add stable idempotency keys, move to batched writes with a flush rule, log intent before consequential actions, and schedule a weekly chain verification with a daily event count check.&lt;/p&gt;

&lt;p&gt;Want to test ZizkaDB on your agent? Try our open source version here: &lt;a href="https://github.com/ZIZKA-AI-SL/ZizkaDB" rel="noopener noreferrer"&gt;https://github.com/ZIZKA-AI-SL/ZizkaDB&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Interested in a design partnership? Fill in the form on our site or reach me directly at &lt;a href="mailto:founder@zizka.ai"&gt;founder@zizka.ai&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Sources: ZizkaDB changelog · ZizkaDB Python SDK wiki · ZizkaDB Audit on GitHub Marketplace · AI Act Article 12 · ZizkaDB repository&lt;/p&gt;

</description>
      <category>ai</category>
      <category>opensource</category>
      <category>programming</category>
      <category>security</category>
    </item>
  </channel>
</rss>
