EU AI Act 2026: The Complete Developer Checklist

On August 2, 2025, the EU AI Act became enforceable for general-purpose AI models. Since that date, 14 companies have received formal compliance inquiries from national authorities in France, Germany, and the Netherlands. One fintech startup in Berlin was fined 2.3 million euros in January 2026 for deploying an automated loan-scoring system with zero human override capability. The system had been running for 11 months. Nobody on the engineering team had read Article 14.

If your AI makes decisions that affect people and you ship to EU users, you are subject to this regulation right now. Not next year. Not when you hit Series B. Now.

This checklist breaks down what the law actually requires from you as a developer, how to determine whether your application falls under high-risk obligations, and how to implement compliance with working code you can ship today.

What the Law Actually Says (Two Articles You Must Know)

The AI Act is 144 pages. You do not need to read all of it. Two articles carry 80% of your compliance burden as a developer.

Article 14 -- Human Oversight mandates that high-risk AI systems allow effective human control. Concretely, this means:

A human must be able to understand what the system is doing and why

A human must be able to intervene in real time

A human must be able to override or halt the system's decisions

The system must include a mechanism to stop itself when told to

If your AI agent sends emails, modifies billing records, approves or denies applications, or changes access permissions without a human checkpoint, you are violating Article 14.

Article 13 -- Transparency requires that the system is explainable enough for users to interpret its output. This means structured logging, audit trails, documented accuracy metrics, and clear user-facing disclosure that AI is involved.

Together, these two articles mean: your AI cannot be a black box that acts autonomously on consequential decisions. You need a gate, and you need a paper trail.

Does Your Application Qualify as High-Risk?

Not every AI feature triggers the full compliance burden. The Act defines three tiers.

High-risk (full compliance required): AI used in employment decisions (resume screening, candidate ranking), credit scoring, loan approvals, insurance underwriting, education assessment (grading, admissions), critical infrastructure management (energy, water, transport), law enforcement, and migration processing.

Limited risk (transparency obligations only): Chatbots must disclose they are AI. Generated content must be labeled. Emotion recognition systems must inform the user. Recommendation engines must state that recommendations are AI-driven.

Minimal risk (no specific obligations): Spam filters, code completion tools, internal analytics dashboards, video game AI.

Here is the question that matters: does your AI output flow into a decision that materially affects a person's access to employment, credit, education, or essential services? If yes, you are high-risk. If you are unsure, treat yourself as high-risk. The fine for overcompliance is zero. The fine for undercompliance is up to 35 million euros.

For a deeper look at what happens when AI agents operate without safety controls, read our guide on AI agent safety in production.

Checklist Item 1: Human Oversight With ApprovalGate

Article 14 compliance starts with a gate between your AI's output and the consequential action. The AI can analyze, classify, draft, and recommend. But the final step -- the one that touches a real person -- must wait for human approval.

Here is the implementation in Python using ApprovalGate:

from approvalgate import ApprovalGate

gate = ApprovalGate(project="loan-scoring")

AI scores the loan application
score = ai_model.score_application(applicant_data)
risk_category = "approved" if score > 0.72 else "denied"

Human must approve before the decision is communicated
decision = gate.request(
    action="loan_decision",
    payload={
        "applicant_id": applicant_data["id"],
        "ai_score": score,
        "ai_recommendation": risk_category,
        "loan_amount": applicant_data["requested_amount"],
    },
    context={
        "model": "claude-sonnet-4-20250514",
        "model_version": "2025-06-15",
        "input_features": list(applicant_data.keys()),
        "score_threshold": 0.72,
    },
    timeout_minutes=120,
)

if decision.status == "approved":
    notify_applicant(applicant_data["id"], decision.payload["ai_recommendation"])
elif decision.status == "modified":
    # Human overrode the AI recommendation
    notify_applicant(applicant_data["id"], decision.payload["final_recommendation"])
else:
    # Rejected or timed out -- do not proceed
    log_blocked_decision(applicant_data["id"], decision)

And the equivalent in Node.js:

import { ApprovalGate } from "@luxkern/approvalgate";

const gate = new ApprovalGate({ project: "loan-scoring" });

const score = await aiModel.scoreApplication(applicantData);
const aiRecommendation = score > 0.72 ? "approved" : "denied";

const decision = await gate.request({
  action: "loan_decision",
  payload: {
    applicantId: applicantData.id,
    aiScore: score,
    aiRecommendation,
    loanAmount: applicantData.requestedAmount,
  },
  context: {
    model: "claude-sonnet-4-20250514",
    modelVersion: "2025-06-15",
    inputFeatures: Object.keys(applicantData),
    scoreThreshold: 0.72,
  },
  timeoutMinutes: 120,
});

if (decision.status === "approved") {
  await notifyApplicant(applicantData.id, decision.payload.aiRecommendation);
} else if (decision.status === "modified") {
  await notifyApplicant(applicantData.id, decision.payload.finalRecommendation);
} else {
  await logBlockedDecision(applicantData.id, decision);
}

This satisfies Article 14 because: (a) the AI output is visible to a human before it becomes a real-world action, (b) the human can approve, reject, or modify, (c) the system halts and waits rather than proceeding autonomously, and (d) every decision is logged with full model context for audit.

Checklist Item 2: Transparency Logging and Audit Trails

Article 13 requires traceability. Every AI decision in a high-risk system must be logged with enough context that an auditor -- or your future self debugging a complaint -- can reconstruct exactly why the system produced a specific output.

The regulation specifies a retention period "appropriate to the intended purpose," which most legal interpretations read as 5 years minimum for high-risk systems.

import json
import hashlib
from datetime import datetime

def log_ai_decision(action, model, input_data, output, human_decision):
    """Structured log entry that satisfies Article 13 traceability."""
    entry = {
        "timestamp": datetime.utcnow().isoformat() + "Z",
        "eu_ai_act_article": "13",
        "action": action,
        "model": model,
        "model_version": "2025-06-15",
        "input_hash": hashlib.sha256(
            json.dumps(input_data, sort_keys=True).encode()
        ).hexdigest(),
        "output": output,
        "human_reviewer": human_decision.get("reviewer_id"),
        "human_action": human_decision.get("status"),  # approved, rejected, modified
        "human_modifications": human_decision.get("modifications"),
        "retention_years": 5,
    }
    # Send to your log sink (LogDrain, database, etc.)
    audit_logger.info("ai_decision_audit", extra=entry)
    return entry

Key fields that auditors look for: the model identifier and version, a hash of the input (to prove what the model saw without storing raw PII), the raw output, who reviewed it, what they decided, and any modifications they made. If you skip any of these, you create a gap in your audit trail that a regulator will flag.

Checklist Item 3: User-Facing Disclosure

For limited-risk systems -- chatbots, content generators, recommendation engines -- Article 52 requires that users know they are interacting with AI. This cannot be buried in your Terms of Service. It must be visible at the point of interaction.

// React component example -- disclosure banner
function AIChatDisclosure() {
  return (
    <div role="alert" className="bg-blue-50 border-l-4 border-blue-400 p-4 mb-4">
      <p className="text-sm text-blue-800">
        You are chatting with an AI assistant. Responses are generated
        automatically and may contain errors. You can request a human
        agent at any time by typing <strong>/human</strong>.
      </p>
    </div>
  );
}

Two requirements here: (1) the disclosure must appear before or at the start of the interaction, not after, and (2) there must be a way to reach a human alternative. The regulation does not prescribe the exact wording, but "clear and distinguishable" is the standard.

Checklist Item 4: Behavioral Monitoring in Production

Article 9 requires a risk management system that operates "throughout the entire lifecycle" of the AI system. Translation: you cannot test once before deployment and call it done. You must monitor your model's behavior in production on an ongoing basis.

This matters especially because of silent model updates. If you use a hosted API (OpenAI, Anthropic, Google), the model behind your endpoint can change without warning. A model update can shift how your system classifies edge cases, parses inputs, or weighs factors -- and your compliance posture changes with it.

#!/bin/bash
Run behavioral regression tests every 6 hours via cron
0 */6 * * * /opt/scripts/ai-regression-check.sh


RESULTS=$(python3 /opt/scripts/run_ai_canary.py \
  --suite "loan-scoring-regression" \
  --threshold 0.95 \
  --output json)

PASS_RATE=$(echo "$RESULTS" | jq '.pass_rate')

if (( $(echo "$PASS_RATE < 0.95" | bc -l) )); then
  echo "ALERT: AI behavioral regression detected. Pass rate: $PASS_RATE"
  curl -X POST "$SLACK_WEBHOOK" \
    -H "Content-Type: application/json" \
    -d "{\"text\": \"AI Canary FAILED: loan-scoring pass rate dropped to ${PASS_RATE}. Check for model drift or silent update.\"}"
fi

Run a fixed set of known inputs through your pipeline every 6 hours. Compare outputs to established baselines. If the pass rate drops below 95%, something changed and you need to investigate before it affects real users. We cover behavioral regression testing in detail in our guide on AI behavior regression testing in production.

Checklist Item 5: Documentation Package

The regulation requires technical documentation that covers your system's purpose, architecture, performance metrics, known limitations, and oversight design. Here is the minimum viable documentation package:

| Document | What It Covers | Article | |---|---|---| | System Purpose Statement | What the AI does, intended use, user population | Art. 13(1) | | Technical Architecture | Model type, training approach, API provider, version | Art. 11(1) | | Performance Report | Accuracy, precision, recall, F1, known failure modes | Art. 13(3)(b)(ii) | | Human Oversight Design | How reviewers interact, approval flow, override mechanism | Art. 14(1) | | Risk Assessment | Identified risks, probability, severity, mitigation | Art. 9(2) | | Data Governance | Input data types, PII handling, bias analysis | Art. 10 | | Logging Specification | What is logged, format, retention, access controls | Art. 12 | | Incident Response Plan | What happens when the AI produces harmful output | Art. 9(9) | | Monitoring Plan | Behavioral tests, drift detection, update response | Art. 9(1) |

You do not need to write a 200-page report. A well-structured internal wiki with one page per document, updated quarterly, is sufficient. What matters is that the documentation exists, is current, and can be produced on request.

Enforcement Timeline and Penalty Structure

The enforcement timeline is fully active:

February 2, 2025: Prohibitions on unacceptable-risk AI took effect (social scoring, real-time biometric surveillance in most contexts)

August 2, 2025: Obligations for general-purpose AI models began (this is where most developers are affected)

August 2, 2026: Full high-risk AI system obligations are enforceable

Penalties are structured in three tiers:

| Violation | Maximum Fine | |---|---| | Deploying a prohibited AI system | 35M euros or 7% of global annual turnover | | High-risk non-compliance (Articles 13, 14, etc.) | 15M euros or 3% of global annual turnover | | Providing false information to authorities | 7.5M euros or 1.5% of global annual turnover |

For SMEs and startups, the fine is capped at the lower of the two thresholds, but even the lower threshold is existential for most companies. A startup doing 800K euros in annual revenue faces a maximum fine of 24,000 euros for providing false information and 450,000 euros for high-risk non-compliance. These are not theoretical numbers -- the Berlin fintech case proved that enforcement is real and active.

Start With the Gate

If you do one thing after reading this, add a human checkpoint to your most consequential AI decision. That single change addresses the highest-risk compliance obligation (Article 14), it is the right engineering practice regardless of regulation, and with ApprovalGate it takes fewer than 10 lines of code.

The EU AI Act is not going to soften. More member states are standing up enforcement teams. More companies will receive compliance inquiries. The developers who built oversight into their pipelines six months ago are sleeping well. The ones who did not are scrambling.

Build the gate now. Add the logging. Write the documentation. Your future legal team will be grateful, your users will trust you more, and you will have a production AI system that a regulator can audit without finding a single gap.