cd /news/ai-agents/how-to-pass-an-enterprise-ai-securit… · home › topics › ai-agents › article
[ARTICLE · art-170480] src=dev.to ↗ pub= topic=ai-agents verified=true sentiment=· neutral

How to Pass an Enterprise AI Security Review: Build an Evidence Pack That Closes Deals

A practitioner guide lays out how vertical AI vendors can build a standing "evidence pack" of tamper-evident, causally linked agent records to answer AI-specific enterprise security review questions, using the open source causal audit database ZizkaDB as the example tooling. The guide identifies five recurring review questions — proof of what an AI did on buyer data, drift detection, prompt injection handling, logging and retention, and human oversight — and pairs each stalling answer with an evidence-backed one, plus a two-week plan and a live replay demo for buyer meetings. It explicitly notes ZizkaDB holds no SOC 2, ISO 42001 or EU AI Act certifications and that the guidance is not legal advice.

by read14 min views1 publishedNov 16, 2026

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.

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.

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.

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.

What changed in enterprise security reviews

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.

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.

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.

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.

The five questions that decide most reviews

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.

The question The answer that stalls The answer with evidence

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

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

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

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

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

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.

The evidence pack, component by component

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.

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.

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.

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.

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.

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.

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.

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.

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.

Building the pack in practice

Make sure the record exists first

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:

python

task = await db.log(agent="review-agent", event="task_received",

    data={"customer": "acme", "type": "contract_review", "case": "K-2041"})

ctx = await db.log(agent="review-agent", event="context_retrieved",

    data={"source": "playbook", "rule": "liability-cap", "rule_v": "v7",

          "trust": "trusted"},

    parent_id=task.id)

dec = await db.log(agent="review-agent", event="decision",

    data={"outcome": "flag", "clause": "12.3", "prompt_v": "v14",

          "model": "provider-model-2026-09"},

    parent_id=ctx.id)

review = await db.log(agent="review-agent", event="human_review",

    data={"reviewer": "r-204", "action": "accepted", "seconds_spent": 41},

    parent_id=dec.id)

Then run the lineage on the decision and keep the output:

python

(await db.why(dec.id)).print() That output, redacted and formatted, becomes your sample trace.

Export the sample trace 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.

Produce the drift report

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.

Verify the chain and store the head elsewhere

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.

Document data handling honestly

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.

Time the incident exercise

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.

Set up the evidence window

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.

Running a live replay in the buyer meeting

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:

Set the scene. Pick a case the buyer's team chooses or approves, ideally from a pilot or a representative sample.

Start from the output. Show the final result and ask the room what question they would ask if this were wrong.

Walk backwards. Run the lineage from the output through the human review, the decision, the retrieved context, to the original request. Narrate each link.

Show the versions. Point out the model and prompt versions on the decision.

Show the human. Show what the reviewer saw and how long they spent.

Show the proof. Run chain verification and explain what it does and does not prove.

Answer the scope question. Show how you would list every other case that used the same input.

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.

Handling the hard objections

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.

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.

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.

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.

What about the EU AI Act? Explain what you know and avoid overclaiming, as covered next.

The regulatory context, briefly

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.

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.

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.

A two week plan

You can build a working pack in two weeks, starting from one agent and one customer.

Week 1: record and measure.

Day 1 to 2: check that causal links, model and prompt versions, customer identifiers and human review events are recorded. Fix gaps.

Day 3: configure redaction and retention, and write the data handling statement.

Day 4: export and annotate a sample trace.

Day 5: choose a baseline period and produce a first drift report.

Week 2: prove and present.

Day 6: run chain verification, set up the schedule and store the chain head outside the database.

Day 7 to 8: run and time the incident exercise, and fix the gaps.

Day 9: set up and test the read-only evidence window.

Day 10: write the one page architecture and the event model table.

Day 11 to 12: assemble the pack and update your standard questionnaire answers.

Day 13 to 14: rehearse the live replay with sales and engineering, and have counsel review the claims.

Common mistakes

Describing instead of showing. Every claim in the pack should point to an artifact.

Overclaiming. Say that the system records, traces, measures and proves the record. Do not say it guarantees correctness or compliance.

A stale pack. An out of date diagram or an expired verification record is worse than none. Assign an owner and a review date.

Storing too much. An audit record full of raw sensitive content can become the thing the buyer worries about. Decide what to keep.

Ignoring versions. Without model and prompt versions, you cannot explain a change in behaviour.

Letting the head live in the same place as the chain. If the same administrator can edit both, the integrity claim is weak.

Leaving sales out. If the sales team cannot run the replay, the pack stays in engineering and the deal still stalls.

Limits to remember

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.

Get started

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.

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

Corrections: if you represent a party named here and believe a statement is inaccurate, contact us and we will review it promptly.

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.

── more in #ai-agents 4 stories · sorted by recency
── more on @zizkadb 3 stories trending now
sponsored brought to you by zahid.host 4,200+ EU-deployed projects
reading about agents? ship yours in a single git push.

Run your AI side-project on zahid.host

EU-based hosting, git-push deploys, automatic HTTPS, no cold starts. Free tier with a custom domain — perfect for shipping the agent you just read about.

$git push zahid main
→ Live at https://your-agent.zahid.host ✓
Get free account → Pricing
from €0/mo · no card required
LIVE [news/how-to-pass-an-enter…] indexed:0 read:14min 2026-11-16 · —