EU AI Act Art.62 AI Office and Board Coordination — Developer Guide (2026)

Chapter VI of the EU AI Act (Articles 57–63) creates an innovation support infrastructure spanning AI regulatory sandboxes, real-world testing, personal data processing rules, SME priority measures, and broader ecosystem support. Article 62 provides the institutional coordination layer that makes this framework function across the EU's 27-member-state structure.

Where Art.57–61 create mechanisms and entitlements for developers, Art.62 establishes how the institutions administering those mechanisms coordinate with each other. The AI Board brings together national competent authorities from all member states. The AI Office acts as the EU-level secretariat and coordination body. Together, they determine how sandbox applications are reviewed across borders, how fee reductions for SMEs are standardised, and how annual reporting on innovation support is compiled.

For developers, Art.62 matters when your AI system crosses member state borders, when you need access to standardised templates that simplify multi-jurisdiction compliance, or when you want to understand how decisions about your sandbox application are made when multiple national authorities are involved.

Art.62 became applicable on 2 August 2025 as part of Chapter VI of the EU AI Act (Regulation (EU) 2024/1689).

Art.62 in the Chapter VI Framework

Art.62 is the governance article of Chapter VI. It does not create new developer entitlements directly — instead, it ensures the institutions responsible for Art.57–61 operate consistently and coherently across the EU. Its practical effect on developers is indirect: better coordination means faster cross-border sandbox decisions, more consistent SME fee reduction policies, and standardised templates that reduce compliance overhead.

What Art.62 Establishes

Core Coordination Obligations

Art.62 requires the AI Board and AI Office to coordinate on Chapter VI implementation in several ways:

1. Sandbox coordination guidance — the AI Board issues common guidance for national competent authorities on AI regulatory sandbox admission criteria, evaluation processes, and exit conditions to ensure consistent implementation across member states

2. Fee reduction standardisation — the AI Office facilitates development of common frameworks for how national competent authorities implement Art.60(1)(e) fee reductions, preventing fragmented approaches that disadvantage SMEs in certain member states

3. Priority access facilitation — the AI Board coordinates how Art.60(1)(a) priority sandbox access is implemented, establishing common timelines and eligibility verification approaches

4. Standard templates and forms — the AI Office develops common templates for sandbox applications, real-world testing plans (Art.58), and SME status declarations (Art.60) that developers can use across any member state

5. Cross-border coordination protocols — for Art.58(7) multi-jurisdiction real-world testing (single submission, multiple authorities), the AI Board establishes the coordination protocols between lead and secondary authorities

6. Annual reporting compilation — the AI Office compiles Art.63 annual reports on sandbox implementation from national authority submissions, providing system-level transparency

The AI Board: Composition and Role

The European AI Board (established under Chapter VII of the EU AI Act, referenced in Art.62 for Chapter VI purposes) is the primary multi-stakeholder coordination body.

Composition

The AI Board consists of:

• One representative per member state — typically the designated national supervisory authority for the AI Act (in Germany: the Federal AI Supervisory Authority; in France: CNIL; in the Netherlands: Dutch AI Authority)
• A representative from the European Data Protection Supervisor (EDPS)
• The AI Office as permanent observer/secretariat
• Optional: Sector-specific representatives when agenda items relate to specific regulated sectors (financial services, healthcare, critical infrastructure)

The Board meets regularly (approximately quarterly for full sessions, with working group meetings more frequently) and publishes its decisions and guidance.

What the AI Board Decides

For Chapter VI purposes, the AI Board:

• Adopts sandbox coordination guidance that member states must follow when establishing and operating AI regulatory sandboxes
• Issues opinions on cross-border sandbox applications when multiple national authorities are involved
• Approves common methodologies for SME status verification under Art.60 (Commission Recommendation 2003/361/EC criteria application)
• Reviews the annual sandbox report compiled by the AI Office from Art.63 submissions

What the AI Board Does NOT Decide

• Individual sandbox admission or rejection decisions (national competent authority decisions)
• Whether a specific AI system is high-risk (national competent authority assessment)
• Penalty amounts for non-compliance (national competent authority enforcement)

For individual developers, the AI Board is rarely a direct interlocutor. Its guidance shapes what national authorities do, which shapes what you experience as the admission process, timelines, and fee structure.

The AI Office: Coordination and Templates

The EU AI Office (established in February 2024 within the European Commission) takes the day-to-day coordination role under Art.62.

AI Office Functions Under Art.62

from dataclasses import dataclass, field
from enum import Enum
from typing import List, Optional
from datetime import date

class AIOfficeTemplateType(Enum):
    SANDBOX_APPLICATION = "sandbox_application"
    REAL_WORLD_TESTING_PLAN = "real_world_testing_plan"
    SME_STATUS_DECLARATION = "sme_status_declaration"
    FEE_REDUCTION_REQUEST = "fee_reduction_request"
    COACHING_SESSION_REQUEST = "coaching_session_request"
    CROSS_BORDER_COORDINATION = "cross_border_coordination"
    ART59_DATA_PROCESSING = "art59_data_processing"

@dataclass
class AIOfficeTemplate:
    """Standard form published by AI Office for Chapter VI procedures."""
    template_type: AIOfficeTemplateType
    template_id: str
    version: str
    published_date: date
    applicable_articles: List[str]
    member_states_adopting: List[str]
    language_versions_available: int = 24  # All EU official languages
    requires_national_supplement: bool = False  # Some states add national fields

    def is_universally_accepted(self) -> bool:
        """Check if template accepted by all 27 member states."""
        return len(self.member_states_adopting) >= 27

    def national_supplement_risk(self) -> str:
        if self.requires_national_supplement:
            return "Review member state supplement before submission — additional fields required"
        return "Standard AI Office template — no national additions expected"

Standard Templates Available

The AI Office publishes and maintains templates for all major Chapter VI procedures:

Using AI Office templates rather than authority-specific forms provides two practical benefits: (1) you do not need to research the submission requirements of each member state separately; (2) national authorities are required to accept them, eliminating rejections for format non-compliance.

Cross-Border Sandbox Coordination Under Art.62

For providers operating across multiple EU member states, Art.62's coordination framework directly affects how cross-border sandbox applications are handled.

Single-Country Sandbox vs Cross-Border Coordination

When you apply for sandbox admission in one member state and later want to extend to others, Art.62 coordination determines your pathway:

from dataclasses import dataclass, field
from typing import List, Optional, Dict
from datetime import date
from enum import Enum

class CoordinationStatus(Enum):
    SINGLE_JURISDICTION = "single_jurisdiction"
    LEAD_AUTHORITY_IDENTIFIED = "lead_authority_identified"
    SECONDARY_AUTHORITIES_NOTIFIED = "secondary_authorities_notified"
    AI_OFFICE_COORDINATING = "ai_office_coordinating"
    MULTI_JURISDICTION_ACTIVE = "multi_jurisdiction_active"
    COMPLETED = "completed"

@dataclass
class CrossBorderSandboxCoordination:
    """Track Art.62 cross-border sandbox coordination for multi-jurisdiction AI deployment."""
    system_name: str
    lead_member_state: str
    lead_authority: str
    lead_sandbox_ref: str

    secondary_member_states: List[str] = field(default_factory=list)
    secondary_authorities: Dict[str, str] = field(default_factory=dict)  # country → authority

    coordination_status: CoordinationStatus = CoordinationStatus.SINGLE_JURISDICTION
    ai_office_reference: Optional[str] = None
    ai_board_opinion_requested: bool = False
    ai_board_opinion_received: Optional[date] = None

    def needs_ai_office_coordination(self) -> bool:
        """Art.62 AI Office coordination triggered when >1 member state involved."""
        return len(self.secondary_member_states) > 0

    def coordination_pathway(self) -> str:
        if not self.needs_ai_office_coordination():
            return "Single-jurisdiction sandbox — no Art.62 cross-border coordination required."
        if len(self.secondary_member_states) <= 2:
            return (
                f"Lead authority ({self.lead_authority}) coordinates bilaterally with "
                f"{', '.join(self.secondary_member_states)} authorities. "
                f"AI Office notified but may not actively coordinate."
            )
        return (
            f"Multi-jurisdiction ({len(self.secondary_member_states) + 1} states) — "
            f"AI Office likely to actively coordinate under Art.62. "
            f"Submit cross-border coordination form to AI Office in parallel with lead authority."
        )

    def ai_board_opinion_warranted(self) -> bool:
        """AI Board opinion appropriate for novel cross-border issues."""
        return (
            len(self.secondary_member_states) >= 3 or
            self.ai_office_reference is not None
        )

The Lead Authority Model

When cross-border coordination is triggered, the AI Board guidance (issued under Art.62) establishes a lead authority model:

1. Lead authority — the national competent authority of the member state where the provider is established or where primary development occurs. This authority handles the sandbox application, conducts the admission assessment, and issues the sandbox decision.

2. Secondary authorities — national competent authorities in other member states where the AI system will be tested or deployed. They receive copies of the sandbox decision and may impose additional national conditions but cannot reject a lead authority approval on grounds already assessed.

3. AI Office coordination — when the lead/secondary arrangement involves substantive disagreement or novel legal questions, the AI Office acts as mediator. The AI Board may issue an opinion if the coordination raises questions of general application.

This model directly parallels the Art.58(7) mechanism for real-world testing: the single-submission approach for multi-jurisdiction real-world testing plans uses the same lead/secondary authority structure.

Fee Reduction Standardisation Under Art.62

Art.60(1)(e) requires national competent authorities to provide fee reductions for SMEs in access to sandboxes and related services. Art.62's coordination role includes preventing fragmentation in how this fee reduction is implemented.

Why Standardisation Matters

Without Art.62 coordination:

• Germany might offer 50% fee reduction; France 30%; Poland a fixed €500 cap
• SME eligibility verification might require different documentation per member state
• A cross-border SME might receive different fee treatment in its lead vs secondary authority jurisdictions

With Art.62 coordination, the AI Board adopts common guidance on:

• Minimum fee reduction percentage (floor across all member states)
• Documentation requirements for SME status declaration (AI Office template)
• Cross-border fee allocation (who charges what when lead/secondary authorities are both involved)

@dataclass
class SMEFeeReductionRequest:
    """Art.60(1)(e) fee reduction request using AI Office standard form."""
    company_name: str
    member_state: str
    authority: str
    sandbox_application_ref: str
    sme_declaration_date: date

    # Commission Recommendation 2003/361/EC verification
    employee_count: int
    annual_turnover_eur: float
    balance_sheet_eur: float
    partner_enterprise_adjustments: bool = False
    linked_enterprise_adjustments: bool = False

    # Fee reduction outcome
    standard_fee_eur: Optional[float] = None
    reduction_percentage: Optional[float] = None
    reduced_fee_eur: Optional[float] = None
    ai_office_template_used: bool = True  # Standardised form = less rejection risk

    def qualifies_as_sme(self) -> bool:
        """Commission Recommendation 2003/361/EC primary criteria."""
        return (
            self.employee_count < 250 and
            (self.annual_turnover_eur <= 50_000_000 or
             self.balance_sheet_eur <= 43_000_000)
        )

    def fee_reduction_risk(self) -> str:
        if not self.qualifies_as_sme():
            return "Does not qualify — exceeds SME thresholds (250 FTE / €50M turnover / €43M balance sheet)"
        if self.partner_enterprise_adjustments or self.linked_enterprise_adjustments:
            return "Enterprise aggregation applies — verify adjusted figures still meet SME thresholds"
        if not self.ai_office_template_used:
            return "Using national form — consider AI Office template to reduce rejection risk"
        return "Eligible — AI Office template + Commission Rec. 2003/361/EC declaration ready"

    def expected_savings(self) -> str:
        if self.standard_fee_eur and self.reduction_percentage:
            savings = self.standard_fee_eur * (self.reduction_percentage / 100)
            return f"Expected saving: €{savings:,.0f} ({self.reduction_percentage}% of €{self.standard_fee_eur:,.0f})"
        return "Fee structure not yet published — check authority website or Art.62 AI Board guidance"

Priority Sandbox Access Coordination

Art.60(1)(a) gives SMEs and startups priority access to regulatory sandboxes. Art.62 coordination ensures this priority is implemented consistently.

Priority Access in Practice

The AI Board guidance on priority access establishes:

• Processing timeline advantage — SME applications are processed within a defined shorter period (typically 30 days vs 45–60 days for non-SME applications)
• Dedicated SME sandbox slots — member states must maintain capacity reservation for SME applicants
• Queue separation — SME applications enter a separate priority queue, not competing directly with large-provider applications

@dataclass
class SandboxPriorityAccessRecord:
    """Track Art.60(1)(a) priority sandbox access application."""
    applicant_name: str
    member_state: str
    authority: str
    application_date: date
    sme_priority_claimed: bool = True

    # Processing timeline (AI Board guidance targets)
    standard_processing_days: int = 45
    sme_priority_processing_days: int = 30
    actual_decision_date: Optional[date] = None
    priority_applied: Optional[bool] = None

    # Admission outcome
    admitted: Optional[bool] = None
    sandbox_ref: Optional[str] = None
    admission_conditions: List[str] = field(default_factory=list)

    def processing_days_elapsed(self, current_date: date) -> int:
        return (current_date - self.application_date).days

    def priority_deadline(self) -> date:
        from datetime import timedelta
        return self.application_date + timedelta(days=self.sme_priority_processing_days)

    def overdue(self, current_date: date) -> bool:
        if self.admitted is not None:
            return False  # Already decided
        return current_date > self.priority_deadline()

    def escalation_pathway(self, current_date: date) -> str:
        if not self.overdue(current_date):
            return f"Within priority window — decision expected by {self.priority_deadline()}"
        return (
            f"Priority deadline exceeded by {(current_date - self.priority_deadline()).days} days. "
            f"Contact authority and reference Art.60(1)(a) + AI Board priority access guidance. "
            f"If unresolved: AI Office escalation pathway available under Art.62."
        )

CLOUD Act Implications for Art.62 Coordination

Art.62 coordination generates significant administrative correspondence — sandbox applications, authority decisions, AI Board opinions, fee reduction approvals, coaching session records. Where this correspondence is stored matters.

What Art.62 Generates That CLOUD Act Can Reach

The CLOUD Act concern with regulatory correspondence is not primarily about the documents themselves — it's that a US government subpoena to AWS, Azure, or GCP seeking documents related to an AI system under regulatory review could compel production of your compliance strategy, authority communications, and legal positions before you have made them public.

CLOUD Act Risk Assessment for Art.62 Activities

from dataclasses import dataclass, field
from typing import List
from enum import Enum

class StorageJurisdiction(Enum):
    EU_SOVEREIGN = "eu_sovereign"
    EU_SUBSIDIARY = "eu_subsidiary_us_parent"  # e.g. AWS eu-central-1 — still CLOUD Act
    US_CLOUD = "us_cloud"
    ON_PREMISE = "on_premise"
    HYBRID = "hybrid"

@dataclass
class Art62CloudActAssessment:
    """CLOUD Act risk assessment for Art.62 coordination activities."""
    company_name: str
    sandbox_application_storage: StorageJurisdiction
    authority_correspondence_storage: StorageJurisdiction
    legal_advice_storage: StorageJurisdiction
    ai_board_opinion_storage: StorageJurisdiction
    fee_documentation_storage: StorageJurisdiction

    HIGH_RISK_JURISDICTIONS = {
        StorageJurisdiction.US_CLOUD,
        StorageJurisdiction.EU_SUBSIDIARY,  # US parent = CLOUD Act jurisdiction
    }

    def exposed_document_categories(self) -> List[str]:
        exposed = []
        if self.sandbox_application_storage in self.HIGH_RISK_JURISDICTIONS:
            exposed.append("Sandbox application (compliance strategy disclosed)")
        if self.authority_correspondence_storage in self.HIGH_RISK_JURISDICTIONS:
            exposed.append("Authority correspondence (regulatory position disclosed)")
        if self.legal_advice_storage in self.HIGH_RISK_JURISDICTIONS:
            exposed.append("Legal advice (attorney-client privilege at risk)")
        if self.ai_board_opinion_storage in self.HIGH_RISK_JURISDICTIONS:
            exposed.append("AI Board opinions (regulatory analysis disclosed)")
        if self.fee_documentation_storage in self.HIGH_RISK_JURISDICTIONS:
            exposed.append("Financial declarations (SME status + financial data)")
        return exposed

    def remediation_priority(self) -> str:
        exposed = self.exposed_document_categories()
        if not exposed:
            return "No CLOUD Act exposure in Art.62 correspondence. Current storage acceptable."
        critical = [e for e in exposed if "legal advice" in e or "correspondence" in e]
        if critical:
            return (
                f"CRITICAL: {len(critical)} high-sensitivity document categories on CLOUD Act-reachable infrastructure. "
                f"Migrate immediately to EU-sovereign storage (on-premise, EU HPC, sota.io). "
                f"All: {'; '.join(exposed)}"
            )
        return (
            f"Moderate CLOUD Act exposure: {len(exposed)} category(ies) on US-reachable infrastructure. "
            f"Migration recommended: {'; '.join(exposed)}"
        )

Annual Reporting Under Art.62 and Art.63

Art.62 assigns the AI Office responsibility for coordinating the annual reporting on AI regulatory sandbox implementation that Art.63 mandates. Understanding this reporting cycle matters for two reasons:

1. Your sandbox experience informs future policy — the annual report feeds AI Board guidance updates, which affect how future sandbox applications are assessed
2. The report is public — the annual report reveals which member states are performing well or poorly on sandbox implementation, creating indirect pressure on authorities

What the Annual Report Covers

@dataclass
class SandboxAnnualReportInsights:
    """Insights from Art.62/63 annual report for developer decision-making."""
    report_year: int
    member_state: str

    # Application statistics
    total_applications: int
    admitted: int
    rejected: int
    withdrawn: int

    # SME statistics
    sme_applications: int
    sme_admitted: int
    sme_fee_reductions_granted: int
    avg_sme_processing_days: Optional[int] = None

    # Cross-border
    cross_border_applications: int = 0

    # Common rejection reasons (ranked)
    top_rejection_reasons: List[str] = field(default_factory=list)

    def admission_rate(self) -> float:
        if self.total_applications == 0:
            return 0.0
        return self.admitted / self.total_applications

    def sme_admission_advantage(self) -> str:
        overall_rate = self.admission_rate()
        sme_rate = self.sme_admitted / self.sme_applications if self.sme_applications > 0 else 0
        diff = sme_rate - overall_rate
        if diff > 0.05:
            return f"SME admission rate ({sme_rate:.0%}) meaningfully above overall ({overall_rate:.0%}) — Art.60 priority working"
        elif diff < -0.05:
            return f"WARNING: SME rate ({sme_rate:.0%}) below overall ({overall_rate:.0%}) — priority not effectively applied"
        return f"Similar admission rates: SME {sme_rate:.0%} vs overall {overall_rate:.0%}"

    def application_readiness_actions(self) -> List[str]:
        """Use annual report data to strengthen application."""
        actions = []
        if self.admission_rate() < 0.5:
            actions.append(f"Competitive market ({self.admission_rate():.0%} admission rate) — strengthen technical documentation before applying")
        if self.top_rejection_reasons:
            actions.append(f"Top rejection reason in {self.report_year}: '{self.top_rejection_reasons[0]}' — explicitly address in application")
        if self.avg_sme_processing_days and self.avg_sme_processing_days > 35:
            actions.append(f"Processing averaging {self.avg_sme_processing_days}d — plan for delay beyond AI Board's 30-day priority target")
        return actions

Practical Art.62 Checklist for Developers

Phase 1: Assess Whether Art.62 Coordination Is Relevant

• Map all EU member states where your AI system will be developed, tested, or deployed
• Identify whether Art.57 sandbox or Art.58 real-world testing involves >1 member state
• Check if your team qualifies as SME under Commission Rec. 2003/361/EC (employee count + turnover/balance sheet + partner/linked enterprise aggregation)
• Identify lead member state (where you are established or primarily developing)
• Identify secondary member states (where you will test or deploy)
• Determine if AI Office cross-border coordination form is needed (triggered by >1 member state involvement)

Phase 2: Templates and Forms

• Download current AI Office standard sandbox application template
• Download AI Office SME Status Declaration template
• Download AI Office Fee Reduction Request Form (if SME)
• Download AI Office Multi-Jurisdiction Submission Form (if Art.58(7) applies)
• Verify current template versions (AI Office publishes updates — check version dates)
• Check whether lead member state requires supplementary national fields

Phase 3: Cross-Border Coordination (if applicable)

• Identify lead authority and obtain authority contact for sandbox/testing enquiries
• Notify secondary authorities per AI Board guidance timelines
• Request AI Office reference number for cross-border coordination tracking
• Check whether AI Board opinion has been requested (for novel cross-border questions)
• Monitor AI Board working group outputs relevant to your sector/case type

Phase 4: Fee Reduction Application (if SME)

• Complete SME Status Declaration using AI Office template
• Document partner enterprise and linked enterprise analysis (if VC-backed or group structure)
• Attach Commission Recommendation 2003/361/EC compliance evidence
• Submit fee reduction request with sandbox application (not after)
• Record fee reduction outcome for Art.11 cost documentation

Phase 5: Infrastructure and CLOUD Act Assessment

• Audit storage location of all sandbox correspondence (applications, decisions, coaching notes)
• Identify any US-cloud storage of authority correspondence or legal advice
• Migrate sensitive regulatory correspondence to EU-sovereign storage
• Document storage jurisdiction for each document category in Art.11 technical documentation
• Establish EU-sovereign CI/CD and deployment pipeline for sandbox-tested AI system

Phase 6: Annual Report Monitoring

• Subscribe to AI Office publication alerts (Art.62/63 annual reports)
• Review annual report for your lead member state (admission rate, processing time, rejection reasons)
• Update sandbox application strategy based on annual report findings
• Track AI Board guidance updates that affect Chapter VI procedures

Art.62 vs Direct Developer Interaction

A common misconception is that Art.62 creates a developer-facing procedure. It does not. Art.62 is an institutional article — it coordinates institutions, not developers.

The practical implication: developers benefit from Art.62 through better institutional quality (consistent decisions, faster processing, standardised forms) rather than through direct Art.62 procedures.

See Also

Art.62 is part of the EU AI Act's Chapter VI coordination framework. For the mechanisms Art.62 coordinates, see our developer guides on Art.57 AI Regulatory Sandboxes, Art.60 SME and Startup Measures, Art.61 Further Innovation Support Measures, and our EU AI Act Hosting Compliance guide for CLOUD Act infrastructure decisions relevant to Art.62 correspondence storage.