
Iso42001 Ai Management
- 82 installs
- 451 repo stars
- Updated July 21, 2026
- borghei/claude-skills
iso42001-ai-management is a skill that automates ISO/IEC 42001 AI Management System readiness assessments, AI impact assessments, and Annex A control checks for AIMS certification.
About
This skill automates ISO/IEC 42001:2023 AI Management System (AIMS) compliance work. It runs a readiness checker that scores every clause and Annex A control, and an impact assessor that evaluates AI systems across fairness, transparency, safety, privacy, security, and accountability. A developer or governance team uses it to prepare for AIMS certification and produce documented gap analyses and risk-treatment recommendations.
- Scores organizational readiness against all ISO 42001 clauses (4-10) and Annex A controls
- Generates AI impact assessments across fairness, transparency, safety, privacy, security dimensions
- Maps risks to EU AI Act risk tiers and ISO 42001 Annex A controls
Iso42001 Ai Management by the numbers
- 82 all-time installs (skills.sh)
- Ranked #1,086 of 2,203 Security skills by installs in the Skillselion catalog
- Data as of Aug 5, 2026 (Skillselion catalog sync)
iso42001-ai-management capabilities & compatibility
- Capabilities
- security audit · compliance check · risk assessment · ai governance
- Use cases
- security audit · research
- Pricing
- Free
What iso42001-ai-management says it does
Assesses organizational readiness against all ISO 42001 clauses and Annex A controls. Scores each clause on a 0-100 scale and identifies gaps for certification preparation.
Generates comprehensive AI impact assessments evaluating fairness, transparency, safety, privacy, and security dimensions.
Tools and guidance for ISO/IEC 42001:2023 — the first international standard for AI Management Systems (AIMS).
npx skills add https://github.com/borghei/claude-skills --skill iso42001-ai-managementAdd your badge
Show developers this skill is listed on Skillselion. Paste this into your README.
| Installs | 82 |
|---|---|
| repo stars | ★ 451 |
| Last updated | July 21, 2026 |
| Repository | borghei/claude-skills ↗ |
What it does
Assess an organization's readiness for ISO 42001 AIMS certification and generate AI impact assessments before deploying an AI system.
Who is it for?
Teams preparing for ISO 42001 AIMS certification or building AI governance and impact-assessment documentation.
Skip if: Teams needing binding legal advice or a certification audit performed by an accredited body.
When should I use this skill?
You need an ISO 42001 readiness score, an AI impact assessment, or an Annex A control gap analysis.
What you get
Produces an overall readiness score, per-clause maturity levels, Annex A control status, and prioritized gap recommendations.
- Readiness score report
- AI impact assessment
- Annex A control gap analysis
By the numbers
- Scores all ISO 42001 clauses 4-10 plus Annex A controls A.2-A.10
- Two Python tools: readiness checker and impact assessor
- Six impact dimensions: fairness, transparency, safety, privacy, security, accountability
Files
ISO 42001 AI Management System
Tools and guidance for ISO/IEC 42001:2023 — the first international standard for AI Management Systems (AIMS).
---
Table of Contents
---
Tools
AIMS Readiness Checker
Assesses organizational readiness against all ISO 42001 clauses and Annex A controls. Scores each clause on a 0-100 scale and identifies gaps for certification preparation.
# Assess readiness from a JSON profile
python scripts/aims_readiness_checker.py --input org_profile.json
# Generate a blank input template
python scripts/aims_readiness_checker.py --template > org_profile.json
# JSON output for automation
python scripts/aims_readiness_checker.py --input org_profile.json --json
# Export report to file
python scripts/aims_readiness_checker.py --input org_profile.json --output report.jsonAssessment Areas:
| Clause | Area | Key Checks |
|---|---|---|
| Clause 4 | Context | Scope defined, interested parties, AIMS boundaries |
| Clause 5 | Leadership | AI policy, governance structure, management commitment |
| Clause 6 | Planning | Risk assessment methodology, AI objectives, impact assessments |
| Clause 7 | Support | Resources, competence, awareness, documentation |
| Clause 8 | Operation | AI lifecycle, data management, risk treatment, third-party controls |
| Clause 9 | Performance | Monitoring, internal audit, management review |
| Clause 10 | Improvement | Corrective actions, continual improvement, incident management |
| Annex A | Controls | A.2-A.10 control implementation status |
Output:
- Overall readiness score (0-100)
- Per-clause scores with maturity level (Initial/Developing/Defined/Managed/Optimized)
- Annex A control implementation status (Implemented/Partial/Not Implemented/Not Applicable)
- Gap analysis with prioritized recommendations
- Certification readiness assessment (Ready/Near Ready/Significant Gaps)
---
AI Impact Assessor
Generates comprehensive AI impact assessments evaluating fairness, transparency, safety, privacy, and security dimensions. Maps impacts to interested parties and provides risk treatment recommendations.
# Assess an AI system from a JSON description
python scripts/ai_impact_assessor.py --input ai_system.json
# Generate a blank input template
python scripts/ai_impact_assessor.py --template > ai_system.json
# Export assessment report
python scripts/ai_impact_assessor.py --input ai_system.json --output assessment.json
# Generate markdown report
python scripts/ai_impact_assessor.py --input ai_system.json --format markdown --output assessment.mdAssessment Dimensions:
| Dimension | Evaluates | Key Factors |
|---|---|---|
| Fairness | Bias, discrimination, equity | Training data diversity, protected attributes, outcome parity |
| Transparency | Explainability, interpretability | Model complexity, decision documentation, user disclosure |
| Safety | Reliability, robustness, harm prevention | Failure modes, edge cases, human oversight, fallback mechanisms |
| Privacy | Data protection, consent, minimization | PI processing, consent mechanisms, data retention, anonymization |
| Security | Adversarial resilience, access control | Attack vectors, model integrity, access management, audit logging |
| Accountability | Governance, responsibility, auditability | Decision ownership, audit trails, escalation procedures |
Features:
- Risk scoring per dimension (Low/Medium/High/Critical)
- Interested party impact mapping (users, affected individuals, society, regulators)
- Risk treatment options (Avoid, Mitigate, Transfer, Accept)
- Regulatory mapping (EU AI Act risk tier, ISO 42001 Annex A controls)
- Residual risk calculation after treatment
- Markdown and JSON report generation
---
Reference Guides
ISO 42001 Clause Guide
references/iso42001-clause-guide.md
Comprehensive clause-by-clause guidance:
- All clauses (4-10) with requirements and implementation steps
- Annex A controls (A.2-A.10) detailed with evidence requirements
- Audit questions per clause for internal audit preparation
- Common nonconformity findings and how to avoid them
- Required documented information per clause
- Cross-references to ISO 27001, ISO 9001, and EU AI Act
AI Lifecycle Management
references/ai-lifecycle-management.md
End-to-end AI system lifecycle guidance:
- Lifecycle stages: design, development, testing, deployment, monitoring, retirement
- Design and development controls (requirements, architecture, coding standards)
- Testing and validation requirements (functional, bias, robustness, performance)
- Deployment procedures (staging, canary, rollback, approval gates)
- Monitoring and maintenance (drift detection, performance degradation, retraining)
- Retirement and decommissioning (data disposal, model archival, stakeholder notification)
- Data management across lifecycle (quality, provenance, bias assessment, lineage)
- Model versioning and change management (version control, change impact, approval workflows)
---
Workflows
Workflow 1: ISO 42001 Readiness Assessment
Step 1: Define AIMS scope
→ Identify AI systems in scope
→ Determine organizational boundaries
→ Document interested parties and requirements
Step 2: Generate assessment template
→ python scripts/aims_readiness_checker.py --template > org_profile.json
→ Fill in organizational details and current state
Step 3: Run readiness assessment
→ python scripts/aims_readiness_checker.py --input org_profile.json
Step 4: Review results
→ Address critical gaps (Clauses 5, 6, 8 typically weakest)
→ Prioritize Annex A controls by risk
→ Develop remediation roadmap
Step 5: Conduct AI impact assessments
→ python scripts/ai_impact_assessor.py --template > ai_system.json
→ Assess each in-scope AI system
→ python scripts/ai_impact_assessor.py --input ai_system.json
Step 6: Plan implementation
→ See references/iso42001-clause-guide.md for requirements
→ See references/ai-lifecycle-management.md for operational controlsWorkflow 2: AI System Impact Assessment
Step 1: Identify AI system for assessment
→ Document system purpose, inputs, outputs, and decisions
→ Identify affected individuals and groups
Step 2: Generate assessment template
→ python scripts/ai_impact_assessor.py --template > ai_system.json
→ Complete all sections (model details, data sources, deployment context)
Step 3: Conduct assessment
→ python scripts/ai_impact_assessor.py --input ai_system.json --format markdown --output report.md
Step 4: Review dimension scores
→ Fairness: check for bias in training data and outcomes
→ Transparency: verify explainability mechanisms
→ Safety: validate failure modes and human oversight
→ Privacy: confirm data protection measures
→ Security: assess adversarial resilience
Step 5: Implement risk treatments
→ Apply recommended mitigations per dimension
→ Document residual risk acceptance decisions
→ Assign treatment owners and timelines
Step 6: Monitor and review
→ Schedule periodic reassessment (quarterly minimum)
→ Track treatment implementation progress
→ Update assessment when system changes materiallyWorkflow 3: AIMS Certification Preparation
Step 1: Gap analysis
→ python scripts/aims_readiness_checker.py --input org_profile.json
→ Target overall score of 80+ for certification readiness
Step 2: Document AIMS
→ AI policy (Clause 5.2)
→ AIMS scope (Clause 4.3)
→ Risk assessment methodology (Clause 6.1)
→ Statement of Applicability for Annex A controls
→ AI objectives (Clause 6.2)
Step 3: Implement operational controls
→ AI lifecycle procedures (Clause 8)
→ Data management processes (Annex A.7)
→ Third-party management (Annex A.10)
→ Impact assessments for all AI systems (Annex A.5)
Step 4: Conduct internal audit
→ Use references/iso42001-clause-guide.md audit questions
→ Document findings and corrective actions
→ Verify closure of nonconformities
Step 5: Management review
→ Present AIMS performance to top management
→ Review AI objectives achievement
→ Obtain commitment for continual improvement
Step 6: Stage 1 and Stage 2 audits
→ Stage 1: Documentation review (readiness check)
→ Stage 2: Implementation effectiveness audit
→ Address any nonconformities from audit---
Standard Overview
ISO 42001:2023 Overview
ISO/IEC 42001:2023 is the world's first international standard for AI Management Systems (AIMS). Published in December 2023, it provides a framework for organizations to responsibly develop, provide, and use AI systems. The standard follows the ISO Harmonized Structure (Annex SL) for management system standards, enabling integration with ISO 27001, ISO 9001, and ISO 14001.
Key Characteristics:
- Certifiable management system standard
- Technology-neutral (applies to any AI approach)
- Risk-based approach to AI governance
- PDCA (Plan-Do-Check-Act) cycle
- Applicable to organizations of any size and sector
AIMS Framework (Plan-Do-Check-Act)
Context of the Organization (Clause 4)
| Requirement | Section | Description |
|---|---|---|
| Organization context | 4.1 | Internal/external issues relevant to AI objectives |
| Interested parties | 4.2 | Stakeholders, their requirements, and expectations |
| AIMS scope | 4.3 | Boundaries and applicability of the AIMS |
| AIMS establishment | 4.4 | Establish, implement, maintain, and improve the AIMS |
Leadership (Clause 5)
| Requirement | Section | Description |
|---|---|---|
| Leadership commitment | 5.1 | Top management demonstrates commitment to AIMS |
| AI policy | 5.2 | Responsible AI principles, ethical guidelines, organizational values |
| Roles and responsibilities | 5.3 | Clear assignment of AIMS roles, authority, and accountability |
AI Policy Must Include:
- Commitment to responsible AI development and use
- Ethical principles guiding AI decisions
- Alignment with applicable legal and regulatory requirements
- Commitment to continual improvement of the AIMS
- Framework for setting AI objectives
AI Governance Structure:
- AI governance board or committee
- AI system owners with defined accountability
- Data stewards for AI data management
- Ethics review function
- Incident response roles
Planning (Clause 6)
| Requirement | Section | Description |
|---|---|---|
| Risks and opportunities | 6.1 | Actions to address AI-specific risks and opportunities |
| AI risk assessment | 6.1.2 | Methodology for identifying and evaluating AI risks |
| AI objectives | 6.2 | Measurable objectives for responsible AI |
| Impact assessment | 6.1.4 | Assessment of AI system impacts on individuals and society |
AI Risk Assessment Must Cover:
- Fairness and non-discrimination risks
- Transparency and explainability gaps
- Safety and reliability concerns
- Privacy and data protection risks
- Security vulnerabilities
- Accountability gaps
- Societal and environmental impacts
Support (Clause 7)
| Requirement | Section | Description |
|---|---|---|
| Resources | 7.1 | Compute, data, expertise, and infrastructure |
| Competence | 7.2 | Required skills for AI roles, training plans |
| Awareness | 7.3 | AI literacy across the organization |
| Communication | 7.4 | Internal/external communication on AI matters |
| Documented information | 7.5 | Document creation, control, and retention |
Operation (Clause 8)
| Requirement | Section | Description |
|---|---|---|
| Operational planning | 8.1 | Planning and controlling AI processes |
| AI risk assessment | 8.2 | Executing risk assessments per methodology |
| AI risk treatment | 8.3 | Implementing risk treatment plans |
| AI system lifecycle | 8.4 | Managing AI systems through all lifecycle stages |
AI System Lifecycle Stages: 1. Design: Requirements, architecture, ethical review 2. Development: Data preparation, model training, coding standards 3. Testing: Functional, bias, robustness, performance validation 4. Deployment: Staging, approval, monitoring setup 5. Operation: Performance monitoring, drift detection, incident response 6. Retirement: Decommissioning, data disposal, stakeholder notification
Data Management for AI:
- Data quality assessment and improvement
- Data provenance and lineage tracking
- Bias assessment in training and evaluation data
- Data governance and access controls
- Personal data protection measures
- Data retention and disposal procedures
Third-Party and Supplier Management:
- AI component supplier evaluation
- Third-party AI service agreements
- Supply chain risk assessment
- Ongoing supplier monitoring
Performance Evaluation (Clause 9)
| Requirement | Section | Description |
|---|---|---|
| Monitoring and measurement | 9.1 | AI system performance metrics and KPIs |
| Internal audit | 9.2 | Planned audits of the AIMS |
| Management review | 9.3 | Top management review of AIMS effectiveness |
AI Performance Metrics:
- Model accuracy, precision, recall
- Fairness metrics (demographic parity, equalized odds)
- Latency and availability
- Drift indicators (data drift, concept drift)
- Incident frequency and severity
- Consumer complaint rates
Improvement (Clause 10)
| Requirement | Section | Description |
|---|---|---|
| Nonconformity | 10.1 | Corrective actions for nonconformities |
| Continual improvement | 10.2 | Ongoing enhancement of the AIMS |
| AI incident management | 10.3 | Handling AI system incidents and near-misses |
Annex A Controls
| Control | Title | Description |
|---|---|---|
| A.2 | AI Policies | Policies for responsible AI aligned with organizational objectives |
| A.3 | Internal Organization | Roles, responsibilities, segregation of duties for AI |
| A.4 | Resources for AI Systems | Compute, data, tools, and expertise management |
| A.5 | Assessing AI System Impact | Impact assessment processes for AI systems |
| A.6 | AI System Lifecycle | Controls across design, development, deployment, retirement |
| A.7 | Data for AI Systems | Data quality, provenance, bias, governance, protection |
| A.8 | Information for Interested Parties | Transparency, disclosure, and communication |
| A.9 | Use of AI Systems | Acceptable use policies, human oversight, user guidance |
| A.10 | Third-Party Relationships | Supplier management, outsourced AI, component evaluation |
Annex B — Implementation Guidance
Annex B provides non-normative guidance for implementing Annex A controls:
- Practical examples for each control objective
- Scalability guidance for different organization sizes
- Sector-specific considerations
- Integration points with existing management systems
Annex C — AI Risk Sources and Objectives
AI-specific risk sources organized by category:
- Technical risks: Model failure, data quality, adversarial attacks, drift
- Ethical risks: Bias, discrimination, lack of transparency, autonomy erosion
- Legal risks: Regulatory non-compliance, liability, intellectual property
- Societal risks: Job displacement, misinformation, environmental impact
- Organizational risks: Skill gaps, dependency, reputation damage
AI-specific control objectives:
- Ensure fairness and non-discrimination
- Maintain transparency and explainability
- Guarantee safety and reliability
- Protect privacy and data
- Secure AI systems against threats
- Enable accountability and governance
Annex D — Use of AIMS Across Domains
Sector-specific considerations:
- Healthcare: Patient safety, clinical validation, regulatory approval (FDA, MDR)
- Finance: Algorithmic trading, credit scoring, anti-money laundering
- Autonomous systems: Safety-critical decisions, human override, fail-safe design
- Human resources: Hiring bias, employee monitoring, fairness
- Public sector: Citizen impact, democratic values, public trust
Relationship to Other Standards
| Standard | Relationship | Integration Points |
|---|---|---|
| ISO 27001 | Information security | Risk assessment, access controls, incident management |
| ISO 9001 | Quality management | Process approach, document control, continual improvement |
| ISO 14001 | Environmental management | Impact assessment, lifecycle thinking |
| ISO 31000 | Risk management | Risk framework, assessment methodology |
| ISO 22989 | AI concepts/terminology | Foundational definitions |
| ISO 23894 | AI risk management | Risk management guidance |
Relationship to EU AI Act
| EU AI Act Requirement | ISO 42001 Mapping |
|---|---|
| Risk management system (Art. 9) | Clause 6.1, 8.2, 8.3, Annex A.5 |
| Data governance (Art. 10) | Clause 8.4, Annex A.7 |
| Technical documentation (Art. 11) | Clause 7.5, Annex A.6 |
| Transparency (Art. 13) | Annex A.8 |
| Human oversight (Art. 14) | Annex A.9 |
| Accuracy, robustness, security (Art. 15) | Clause 9.1, Annex A.6 |
| Quality management system (Art. 17) | Full AIMS (Clauses 4-10) |
| Conformity assessment | Certification process |
Certification Process
| Phase | Activity | Duration |
|---|---|---|
| Preparation | Gap analysis, implementation, internal audit | 6-12 months |
| Stage 1 Audit | Documentation review, readiness assessment | 1-2 days |
| Gap Remediation | Address Stage 1 findings | 1-3 months |
| Stage 2 Audit | Implementation effectiveness assessment | 2-5 days |
| Certification | Certificate issued (3-year validity) | Upon passing |
| Surveillance | Annual surveillance audits | 1-2 days/year |
| Recertification | Full reassessment every 3 years | 2-4 days |
Implementation Roadmap
Phase 1 — Foundation (Months 1-3):
- Define AIMS scope and boundaries
- Establish AI governance structure
- Develop AI policy
- Conduct initial AI system inventory
- Define risk assessment methodology
Phase 2 — Core Implementation (Months 4-6):
- Conduct AI risk assessments for all in-scope systems
- Perform impact assessments (Annex A.5)
- Implement AI lifecycle controls (Annex A.6)
- Establish data management processes (Annex A.7)
- Develop third-party management procedures (Annex A.10)
Phase 3 — Operationalize (Months 7-9):
- Deploy monitoring and measurement (Clause 9.1)
- Train personnel on AIMS roles and responsibilities
- Implement incident management procedures
- Conduct awareness programs for AI literacy
- Establish communication processes
Phase 4 — Verify and Certify (Months 10-12):
- Conduct internal audit (Clause 9.2)
- Hold management review (Clause 9.3)
- Address nonconformities
- Prepare for Stage 1 certification audit
- Compile evidence packages per clause
---
Troubleshooting
| Problem | Possible Cause | Resolution |
|---|---|---|
| Readiness score low on Clause 5 (Leadership) despite executive sponsorship | AI policy does not include ethical principles, responsible AI commitment, or framework for setting AI objectives | Update AI policy to explicitly address all required elements: ethical principles, responsible AI, legal alignment, continual improvement commitment, and AI objectives framework; obtain formal management sign-off |
| AI impact assessment returns High/Critical risk across all dimensions | AI system processes sensitive personal data, makes autonomous decisions, and affects large populations without safeguards | Implement targeted mitigations per dimension: human-in-the-loop for safety, bias testing for fairness, explainability mechanisms for transparency, data protection for privacy; re-run assessment after mitigation |
| Annex A controls scored as "Not Implemented" despite operational practices | Practices exist informally but are not documented per ISO 42001 requirements | Document all existing AI practices as formal procedures; create evidence artifacts (policy documents, meeting minutes, risk registers, training records); map to specific Annex A control objectives |
| Certification body auditor questions AI risk assessment methodology | Risk assessment does not cover all seven required risk categories (fairness, transparency, safety, privacy, security, accountability, societal) | Update risk assessment methodology to explicitly address all ISO 42001 risk categories; use ai_impact_assessor.py template to ensure comprehensive coverage; document risk criteria and tolerance levels |
| Third-party AI components lack governance controls | Organization uses third-party AI models or APIs without formal evaluation or supplier management | Implement Annex A.10 (Third-Party Relationships) controls; evaluate all third-party AI components; establish contractual requirements for AI service providers; monitor supplier AI practices |
| Data management procedures incomplete for AI lifecycle | Data quality, provenance, and bias assessment not systematically performed for training and evaluation data | Implement Annex A.7 (Data for AI Systems) controls; establish data quality assessment procedures; document data provenance and lineage; conduct bias assessments per dataset; define retention and disposal procedures |
| Stage 1 audit finds AIMS documentation insufficient | Documentation follows generic QMS structure without AI-specific elements | Restructure documentation to address all ISO 42001 clauses (4-10) and Annex A controls (A.2-A.10); include AI-specific policies, risk assessments, impact assessments, and lifecycle procedures |
---
Success Criteria
- Overall readiness score of 80+ for certification readiness -- as measured by
aims_readiness_checker.py, with all clauses at Defined maturity level or above - AI policy established and communicated -- including ethical principles, responsible AI commitment, legal compliance alignment, continual improvement, and framework for AI objectives, with formal management approval
- AI impact assessments completed for all in-scope AI systems -- covering all six dimensions (fairness, transparency, safety, privacy, security, accountability) with risk treatments documented and residual risk accepted by management
- AI risk assessment methodology covers all required categories -- fairness, transparency, safety, privacy, security, accountability, and societal/environmental impacts, with defined risk criteria and tolerance levels
- Annex A controls implemented with evidence -- A.2 (Policies) through A.10 (Third-Party) with documented procedures, records, and evidence artifacts suitable for certification audit
- Internal audit conducted against all AIMS clauses -- with findings documented, corrective actions tracked to closure, and management review completed with documented improvement decisions
- AI lifecycle procedures operational -- covering design, development, testing, deployment, monitoring, and retirement stages with documented controls at each gate
---
Scope & Limitations
In Scope:
- ISO 42001:2023 readiness assessment across all clauses (4-10) and Annex A controls (A.2-A.10)
- AI impact assessment across six dimensions (fairness, transparency, safety, privacy, security, accountability)
- AIMS certification preparation including gap analysis, implementation roadmap, and audit readiness
- AI lifecycle management guidance (design through retirement)
- Data management for AI systems (quality, provenance, bias, governance)
- Third-party AI supplier management and evaluation
- Regulatory mapping to EU AI Act requirements
- Integration guidance with ISO 27001, ISO 9001, and ISO 14001
Out of Scope:
- Actual AI model development, training, testing, or deployment -- this skill provides governance frameworks, not ML engineering
- Certification body selection, audit scheduling, or certification fee negotiation
- Ethical review board establishment or ethical decision-making beyond procedural guidance
- Specific AI fairness algorithm implementation (e.g., adversarial debiasing, calibrated equalized odds) -- use
eu-ai-act-specialistbias detector for technical testing - Environmental impact measurement or carbon footprint calculation for AI training
Important Notes:
- ISO 42001 certification follows a 3-year cycle with annual surveillance audits at 12-month intervals
- Major certification bodies (BSI, DNV, TUV, LRQA) have operationalized ISO 42001 audit services as of 2025-2026
- Many organizations pursue dual alignment: ISO 42001 certification for governance controls plus EU AI Code of Practice for regulatory expectations
- The standard's Annex SL structure enables direct integration with ISO 27001, reducing redundant documentation and audit effort
---
Integration Points
| Skill | Integration | When to Use |
|---|---|---|
eu-ai-act-specialist | ISO 42001 AIMS maps directly to EU AI Act requirements; certification demonstrates Art. 17 QMS compliance | When building AI governance satisfying both ISO 42001 and EU AI Act obligations |
information-security-manager-iso27001 | ISO 27001 security controls integrate with AIMS via shared Annex SL structure; risk assessment methodologies align | When implementing joint ISMS + AIMS covering both information security and AI governance |
gdpr-dsgvo-expert | AIMS data management (Annex A.7) aligns with GDPR data protection requirements; AI processing requires DPIA | When AI systems process personal data and require both AIMS and GDPR compliance |
isms-audit-expert | Internal audit methodology and finding management shared between ISO 27001 and ISO 42001 | When conducting internal audits covering both ISMS and AIMS |
---
Tool Reference
aims_readiness_checker.py
Assesses organizational readiness against all ISO 42001:2023 clauses and Annex A controls.
| Flag | Required | Description |
|---|---|---|
--input <file> | Yes (unless --template) | Path to JSON organizational profile for assessment |
--template | No | Generate blank input template to stdout |
--json | No | Output results in JSON format for automation |
--output <file> | No | Export report to specified file path |
Assessment Scope: Clause 4 (Context), Clause 5 (Leadership), Clause 6 (Planning), Clause 7 (Support), Clause 8 (Operation), Clause 9 (Performance), Clause 10 (Improvement), and Annex A controls (A.2-A.10).
Output: Overall readiness score (0-100), per-clause scores with maturity level (Initial/Developing/Defined/Managed/Optimized), Annex A control implementation status, gap analysis with prioritized recommendations, and certification readiness assessment (Ready/Near Ready/Significant Gaps).
ai_impact_assessor.py
Generates comprehensive AI impact assessments across six risk dimensions with regulatory mapping.
| Flag | Required | Description |
|---|---|---|
--input <file> | Yes (unless --template) | Path to JSON AI system description for assessment |
--template | No | Generate blank AI system template to stdout |
--format <fmt> | No | Output format: json (default) or markdown |
--output <file> | No | Export assessment report to specified file path |
Assessment Dimensions: Fairness (bias, discrimination, equity), Transparency (explainability, interpretability), Safety (reliability, robustness, harm prevention), Privacy (data protection, consent, minimization), Security (adversarial resilience, access control), Accountability (governance, responsibility, auditability).
Output: Per-dimension risk scoring (Low/Medium/High/Critical), interested party impact mapping, risk treatment options (Avoid/Mitigate/Transfer/Accept), regulatory mapping (EU AI Act risk tier, ISO 42001 Annex A controls), residual risk calculation, and markdown or JSON report.
AI Lifecycle Management Guide
Comprehensive guidance for managing AI systems through all lifecycle stages per ISO 42001:2023 Clause 8 and Annex A.6. Covers design, development, testing, deployment, monitoring, retirement, data management, and model versioning.
---
Table of Contents
- Lifecycle Overview
- Stage 1: Design
- Stage 2: Development
- Stage 3: Testing and Validation
- Stage 4: Deployment
- Stage 5: Monitoring and Maintenance
- Stage 6: Retirement and Decommissioning
- Data Management Across Lifecycle
- Model Versioning and Change Management
---
Lifecycle Overview
┌──────────┐ ┌─────────────┐ ┌──────────┐ ┌────────────┐
│ DESIGN │───>│ DEVELOPMENT │───>│ TESTING │───>│ DEPLOYMENT │
└──────────┘ └─────────────┘ └──────────┘ └────────────┘
^ │
│ v
│ ┌──────────────┐ ┌────────────────────────────┐
└──────────│ RETIREMENT │<───│ MONITORING & MAINTENANCE │
└──────────────┘ └────────────────────────────┘Gate Reviews: Each transition between stages requires a formal gate review to verify readiness, address risks, and approve progression.
| Gate | From → To | Key Criteria |
|---|---|---|
| G1 | Design → Development | Requirements approved, ethical review passed, impact assessment completed |
| G2 | Development → Testing | Model meets baseline performance, code reviewed, data documented |
| G3 | Testing → Deployment | All test criteria met, bias assessment passed, security validated |
| G4 | Deployment → Operation | Monitoring configured, rollback tested, stakeholders notified |
| G5 | Operation → Retirement | Retirement plan approved, data disposal planned, users notified |
---
Stage 1: Design
Requirements Definition
Functional Requirements:
- Problem statement and business objective
- Input data specification (types, sources, formats)
- Output specification (predictions, classifications, recommendations)
- Performance requirements (accuracy, latency, throughput)
- Scalability and availability requirements
Responsible AI Requirements:
- Fairness criteria and protected attribute handling
- Transparency and explainability requirements
- Safety and reliability requirements
- Privacy and data protection requirements
- Security requirements
- Human oversight requirements
- Regulatory compliance requirements (EU AI Act, sector-specific)
Architecture Design
Design Decisions to Document:
- Model architecture selection rationale
- Training approach (supervised, unsupervised, reinforcement, fine-tuning)
- Feature engineering strategy
- Data pipeline architecture
- Inference pipeline design
- Integration architecture (APIs, batch, real-time)
- Failover and fallback design
- Human-in-the-loop integration points
Ethical Review
Before proceeding to development:
- Conduct ethical review with diverse stakeholders
- Assess potential for discrimination or bias
- Evaluate societal impact (positive and negative)
- Consider dual-use risks
- Document ethical review findings and mitigations
- Obtain ethics board approval for high-risk applications
Impact Assessment
Per ISO 42001 Annex A.5:
- Assess impact on all identified interested parties
- Evaluate fairness, transparency, safety, privacy, security dimensions
- Map impacts to risk levels
- Define risk treatment measures
- Document residual risk and acceptance rationale
Gate G1 Checklist:
- [ ] Requirements documented and approved
- [ ] Architecture design documented
- [ ] Ethical review completed
- [ ] Impact assessment completed
- [ ] Resource requirements identified
- [ ] Development plan approved
- [ ] Risks identified and treatment planned
---
Stage 2: Development
Data Preparation
Data Collection:
- Document data sources with provenance
- Verify legal basis for data collection and use
- Assess data representativeness for target population
- Document consent/authorization for personal data
- Establish data labeling guidelines and quality criteria
Data Quality Assessment:
| Quality Dimension | Assessment Method | Minimum Threshold |
|---|---|---|
| Completeness | Missing value analysis | Define per feature |
| Accuracy | Cross-reference with ground truth | > 95% |
| Consistency | Cross-source validation | No contradictions |
| Timeliness | Data freshness analysis | Within defined window |
| Uniqueness | Deduplication analysis | < 1% duplicates |
| Representativeness | Demographic distribution analysis | Proportional to target |
Bias Assessment in Data:
- Analyze demographic distribution in training data
- Identify underrepresented groups
- Check for historical bias in labels
- Assess proxy variables for protected attributes
- Document mitigation steps taken (resampling, reweighting, augmentation)
Model Training
Development Standards:
- Use version control for all code, configurations, and data references
- Follow coding standards appropriate to the ML framework
- Document hyperparameter selection rationale
- Implement reproducibility measures (random seeds, environment pinning)
- Conduct code reviews for ML pipeline code
- Separate training, validation, and test datasets (no data leakage)
Training Documentation:
- Training data description (size, composition, preprocessing)
- Model architecture and configuration
- Hyperparameter search strategy and results
- Training process (epochs, convergence, compute used)
- Validation results during training
- Known limitations discovered during training
Code Review for AI
In addition to standard code review:
- Verify data preprocessing does not introduce bias
- Check for data leakage between train/test splits
- Validate feature engineering logic
- Review model serialization and loading
- Verify reproducibility settings
- Check for hardcoded assumptions or thresholds
Gate G2 Checklist:
- [ ] Training data documented with provenance
- [ ] Data quality assessment completed
- [ ] Bias assessment conducted on data
- [ ] Model trained and validated
- [ ] Code reviewed
- [ ] Baseline performance metrics met
- [ ] Development artifacts versioned
---
Stage 3: Testing and Validation
Functional Testing
| Test Type | Purpose | Criteria |
|---|---|---|
| Unit tests | Component-level correctness | All pass |
| Integration tests | Pipeline end-to-end correctness | All pass |
| Performance tests | Accuracy, precision, recall on test set | Meet thresholds |
| Latency tests | Response time under load | Within SLA |
| Scalability tests | Behavior under increasing load | Linear scaling |
| Edge case tests | Handling of unusual inputs | Graceful handling |
| Input validation | Rejection of malformed inputs | No unhandled errors |
Bias and Fairness Testing
Required Metrics:
| Metric | Description | Threshold |
|---|---|---|
| Demographic parity | Equal positive rates across groups | Ratio > 0.8 |
| Equalized odds | Equal TPR and FPR across groups | Difference < 0.1 |
| Disparate impact | Four-fifths rule compliance | Ratio > 0.8 |
| Calibration | Predicted probabilities match outcomes per group | Within 0.05 |
| Counterfactual fairness | Same prediction if protected attribute changed | Match rate > 95% |
Testing Approach: 1. Define protected attributes and demographic groups 2. Create test datasets stratified by protected attributes 3. Measure all fairness metrics per group pair 4. Document any disparities and root cause analysis 5. Apply mitigation if thresholds are not met 6. Retest after mitigation
Robustness Testing
- Adversarial testing: Test with adversarial examples (perturbed inputs)
- Out-of-distribution: Test with data outside training distribution
- Noise tolerance: Test with noisy or corrupted inputs
- Missing data: Test with missing features
- Temporal robustness: Test with data from different time periods
- Stress testing: Test under resource constraints (CPU, memory, network)
Security Testing
- Model extraction: Assess vulnerability to model stealing attacks
- Data poisoning: Validate training pipeline integrity
- Prompt injection: Test for prompt injection vulnerabilities (LLMs)
- API security: Standard API security testing (authentication, authorization, rate limiting)
- Input sanitization: Validate input validation effectiveness
- Output filtering: Verify output filtering for harmful content
Validation by Independent Party
For high-risk AI systems:
- Validation by team independent from development
- Use held-out validation dataset not seen during development
- Validate against original requirements and responsible AI criteria
- Document validation results and any residual concerns
- Obtain sign-off from independent validator
Gate G3 Checklist:
- [ ] All functional tests passed
- [ ] Bias and fairness testing completed — thresholds met
- [ ] Robustness testing passed
- [ ] Security testing completed — no critical vulnerabilities
- [ ] Independent validation completed (if required)
- [ ] Test results documented and reviewed
- [ ] Deployment plan approved
---
Stage 4: Deployment
Pre-Deployment
Deployment Plan Must Include:
- Deployment environment and infrastructure
- Deployment approach (canary, blue-green, rolling, big-bang)
- Rollback procedure and triggers
- Monitoring and alerting configuration
- Stakeholder notification plan
- Go/no-go criteria and decision authority
Canary and Staged Deployment
Recommended Approach: 1. Shadow mode: Run new model alongside existing system, compare outputs 2. Canary (1-5%): Route small percentage of traffic to new model 3. Gradual rollout (5-25-50-100%): Increase traffic incrementally 4. Full deployment: Route all traffic after validation at each stage
At each stage, monitor:
- Model performance metrics vs. baseline
- Fairness metrics vs. baseline
- Error rates and failure modes
- Latency and resource utilization
- User feedback and complaints
- Business metrics impact
Approval Gates
Who must approve deployment:
- AI system owner
- Technical lead
- Risk/compliance representative
- Ethics reviewer (for high-risk systems)
- Business stakeholder
Approval documentation:
- Test results summary
- Risk assessment status
- Compliance verification
- Deployment plan
- Rollback plan
Post-Deployment Verification
Within first 24-72 hours:
- Verify monitoring and alerting is operational
- Confirm model performance matches testing results
- Check fairness metrics in production
- Verify logging and audit trail capture
- Confirm rollback capability is functional
- Validate user-facing transparency mechanisms
Gate G4 Checklist:
- [ ] Deployment plan executed
- [ ] Monitoring and alerting confirmed operational
- [ ] Production performance verified against test results
- [ ] Rollback tested and confirmed functional
- [ ] Stakeholders notified
- [ ] Post-deployment verification completed
---
Stage 5: Monitoring and Maintenance
Continuous Monitoring
Performance Monitoring:
- Model accuracy, precision, recall (vs. baseline and threshold)
- Prediction distribution (detect distribution shifts)
- Response latency (P50, P95, P99)
- Throughput and error rates
- Resource utilization (CPU, GPU, memory)
Drift Detection:
| Drift Type | Detection Method | Action Threshold |
|---|---|---|
| Data drift | Population Stability Index (PSI) | PSI > 0.2 |
| Feature drift | KS test per feature | p-value < 0.05 |
| Concept drift | Performance degradation over time | Accuracy drop > 5% |
| Prediction drift | Output distribution shift | PSI > 0.1 |
| Label drift | Ground truth label distribution change | Chi-squared test |
Fairness Monitoring:
- Continuous tracking of fairness metrics per demographic group
- Alert when fairness metrics cross thresholds
- Quarterly comprehensive fairness review
Incident Detection:
- Anomaly detection on model outputs
- User complaint/feedback monitoring
- Automated alerting for performance degradation
- Security event monitoring
Maintenance Activities
Routine Maintenance:
- Weekly: Review monitoring dashboards and alerts
- Monthly: Performance report and trend analysis
- Quarterly: Comprehensive fairness and drift review
- Annually: Full model revalidation and impact reassessment
Retraining Triggers:
- Significant data drift detected (PSI > 0.25)
- Performance below acceptable threshold
- Concept drift confirmed by ground truth analysis
- New data sources or features available
- Regulatory or business requirement changes
- Bias detected in production fairness monitoring
Retraining Process: 1. Identify need for retraining (trigger event) 2. Prepare updated training data with quality and bias checks 3. Retrain model following development standards 4. Conduct full testing suite (functional, fairness, robustness, security) 5. Validate against production performance 6. Deploy via staged deployment process 7. Monitor post-retraining performance
Incident Response
Severity Levels:
| Level | Description | Response Time | Example |
|---|---|---|---|
| P1 - Critical | AI system causing active harm | < 1 hour | Discriminatory decisions affecting individuals |
| P2 - High | Significant performance degradation | < 4 hours | Model accuracy dropped below minimum threshold |
| P3 - Medium | Non-critical issue affecting quality | < 24 hours | Drift detected but within tolerance |
| P4 - Low | Minor issue, no immediate impact | < 1 week | Documentation gap identified |
Response Procedure: 1. Detect: Alert triggered or report received 2. Triage: Classify severity, assign owner 3. Contain: Disable system, rollback, or enable human override 4. Investigate: Root cause analysis 5. Resolve: Fix and verify 6. Communicate: Notify affected parties 7. Learn: Document lessons learned, update controls
---
Stage 6: Retirement and Decommissioning
Retirement Triggers
- Model superseded by improved version
- Business use case no longer relevant
- Regulatory changes making system non-compliant
- Unacceptable risk that cannot be mitigated
- Cost-benefit analysis no longer favorable
- Technology obsolescence
Retirement Planning
Retirement Plan Must Include:
- Retirement timeline and milestones
- Stakeholder notification plan
- Data disposition plan (archive, delete, anonymize)
- Model artifact archival plan
- Documentation preservation
- Service migration plan (for dependent systems)
- User communication and transition support
- Compliance obligations during and after retirement
Data Disposition
| Data Type | Disposition Options | Considerations |
|---|---|---|
| Training data | Archive or delete per retention policy | Legal holds, regulatory requirements |
| Personal data | Delete per privacy law requirements | GDPR Art. 17, CCPA §1798.105 |
| Model artifacts | Archive for audit trail | Retain for regulatory inquiry period |
| Evaluation data | Archive for reproducibility | Anonymize if containing personal data |
| Monitoring logs | Retain per log retention policy | Legal and compliance requirements |
| Configuration | Archive for reference | May be needed for incident investigation |
Stakeholder Notification
Notify the following parties before retirement:
- End users and affected individuals
- Business stakeholders and system owners
- Downstream system owners (API consumers)
- Regulatory bodies (if required)
- Third-party providers and suppliers
- Internal teams (development, operations, support)
Notification Timeline:
- 90 days: Initial notification of planned retirement
- 30 days: Reminder with migration guidance
- 7 days: Final notification
- Day 0: System retired, redirect/deprecation notice active
Gate G5 Checklist:
- [ ] Retirement plan approved
- [ ] Stakeholders notified (90/30/7 day)
- [ ] Data disposition executed per plan
- [ ] Model artifacts archived
- [ ] Documentation preserved
- [ ] Dependent systems migrated
- [ ] Retirement verified and confirmed
---
Data Management Across Lifecycle
Data Governance Framework
Principles:
- Quality: Data must meet defined quality standards before use in AI
- Provenance: Data origin and transformation history must be traceable
- Protection: Personal and sensitive data must be protected throughout lifecycle
- Minimization: Only data necessary for the purpose should be collected and retained
- Fairness: Data must be assessed for bias and representativeness
- Retention: Data must be retained only as long as necessary
Data Quality Management
Quality Dimensions:
| Dimension | Definition | Assessment Frequency |
|---|---|---|
| Accuracy | Data correctly represents real-world entity | Before each training cycle |
| Completeness | All required data present | Continuous monitoring |
| Consistency | No contradictions across sources | Before each training cycle |
| Timeliness | Data sufficiently current | Continuous monitoring |
| Validity | Data conforms to defined rules/formats | Continuous validation |
| Uniqueness | No unnecessary duplicates | Before each training cycle |
Data Provenance and Lineage
Document for all data used in AI systems:
- Origin: Where did the data come from?
- Collection method: How was it collected?
- Legal basis: What authorizes its use?
- Transformations: What preprocessing was applied?
- Versioning: Which version of the data was used?
- Quality scores: What were the quality assessment results?
- Bias assessment: What bias checks were performed?
Data Bias Assessment
Assessment Steps: 1. Define protected attributes and demographic groups 2. Analyze representation in training data vs. target population 3. Check for historical bias in labels or outcomes 4. Identify proxy variables for protected attributes 5. Test for measurement bias (different accuracy across groups) 6. Document findings and mitigation strategies 7. Repeat assessment when data is updated
Bias Mitigation Techniques:
| Technique | Stage | Approach |
|---|---|---|
| Resampling | Pre-processing | Oversample minority, undersample majority |
| Reweighting | Pre-processing | Assign higher weights to underrepresented samples |
| Data augmentation | Pre-processing | Generate synthetic data for underrepresented groups |
| Adversarial debiasing | In-processing | Train adversarial network to remove bias signals |
| Calibration | Post-processing | Adjust predictions to equalize across groups |
| Threshold adjustment | Post-processing | Set group-specific decision thresholds |
---
Model Versioning and Change Management
Version Control Requirements
What to Version:
- Source code (ML pipeline, preprocessing, inference)
- Model artifacts (trained weights, architecture files)
- Training data references (dataset version, not data copies)
- Configuration files (hyperparameters, feature definitions)
- Test datasets and evaluation scripts
- Documentation (model card, impact assessment)
Versioning Scheme
Recommended: Semantic Versioning for Models
MAJOR.MINOR.PATCH
MAJOR: Architecture change, new training data source, significant behavior change
MINOR: Hyperparameter tuning, incremental retraining, feature addition
PATCH: Bug fix, configuration update, documentation updateExample:
- v1.0.0: Initial production deployment
- v1.1.0: Retraining with updated data
- v1.1.1: Fixed preprocessing bug
- v2.0.0: New model architecture
Change Management Process
Change Types:
| Change Type | Approval Required | Testing Required |
|---|---|---|
| Emergency (P1 fix) | AIMS manager + system owner | Abbreviated test suite |
| Standard (planned) | Change board approval | Full test suite |
| Minor (config/docs) | System owner | Relevant tests only |
Change Request Process: 1. Submit change request with rationale and impact analysis 2. Assess impact on fairness, safety, privacy, security 3. Review by appropriate authority (see table above) 4. Implement change in development environment 5. Execute required testing 6. Deploy via staged deployment process 7. Verify change in production 8. Update documentation and version records
Model Registry
Maintain a central model registry containing:
- Model ID and version
- Architecture and framework
- Training data version reference
- Performance metrics (training, validation, production)
- Fairness metrics
- Owner and team
- Deployment status (development, staging, production, retired)
- Risk classification
- Dependencies (libraries, infrastructure)
- Approval records
- Known limitations and constraints
Rollback Procedures
When to Roll Back:
- Performance degradation exceeding threshold
- Fairness violation detected
- Security vulnerability discovered
- Unexpected behavior in production
- Business impact exceeding risk appetite
Rollback Process: 1. Decision to rollback (system owner or on-call authority) 2. Redirect traffic to previous model version 3. Verify previous version is serving correctly 4. Disable new version deployment 5. Notify stakeholders of rollback 6. Investigate root cause 7. Plan corrective action before re-deployment 8. Document rollback decision and rationale
ISO 42001:2023 Clause-by-Clause Guide
Comprehensive implementation guidance for ISO/IEC 42001:2023 — AI Management Systems (AIMS). Covers all clauses (4-10), Annex A controls (A.2-A.10), audit questions, common findings, and evidence requirements.
---
Table of Contents
- Clause 4 — Context of the Organization
- Clause 5 — Leadership
- Clause 6 — Planning
- Clause 7 — Support
- Clause 8 — Operation
- Clause 9 — Performance Evaluation
- Clause 10 — Improvement
- Annex A Controls
- Cross-Standard Mapping
- EU AI Act Alignment
---
Clause 4 — Context of the Organization
4.1 Understanding the Organization and Its Context
Requirement: Determine external and internal issues relevant to the organization's purpose and that affect its ability to achieve the intended outcomes of its AIMS.
AI-Specific Issues to Document:
- External: Regulatory landscape (EU AI Act, national AI strategies), industry standards, public trust in AI, competitor AI capabilities, technology evolution, societal expectations for responsible AI
- Internal: AI maturity level, data infrastructure, talent availability, organizational culture toward AI adoption, existing management systems (ISO 27001, 9001)
Implementation Steps: 1. Conduct environmental scan for AI-related factors 2. Assess organizational AI maturity using a maturity model 3. Identify regulatory requirements applicable to AI systems 4. Document stakeholder expectations regarding AI 5. Review annually and update when context changes materially
Evidence Required:
- Context analysis document
- PESTLE or similar environmental analysis for AI factors
- AI maturity assessment results
Audit Questions:
- How has the organization identified external issues affecting its use of AI?
- What internal factors have been considered in establishing the AIMS?
- How does the organization monitor changes in its AI context?
Common Findings:
- Context analysis is generic and does not address AI-specific issues
- No consideration of societal impact or public trust factors
- Context not reviewed when new AI systems are deployed
4.2 Understanding the Needs and Expectations of Interested Parties
Requirement: Determine interested parties relevant to the AIMS and their requirements.
Key Interested Parties for AI:
| Interested Party | Typical Requirements |
|---|---|
| Consumers/users | Transparency, fairness, privacy, safety, explainability |
| Affected individuals | Non-discrimination, redress mechanisms, informed consent |
| Regulators | Compliance with AI regulations, reporting, documentation |
| Employees | AI literacy, job security concerns, ethical guidelines |
| Shareholders/investors | Risk management, governance, responsible innovation |
| Society | Safety, environmental impact, democratic values |
| Business partners | Data quality, security, liability allocation |
| Industry bodies | Standards compliance, best practices |
Evidence Required:
- Interested party register with requirements
- Stakeholder engagement records
- Regulatory requirement mapping
Audit Questions:
- Who are the interested parties for each AI system?
- How are their requirements determined and monitored?
- How are conflicting requirements between parties resolved?
4.3 Determining the Scope of the AIMS
Requirement: Determine the boundaries and applicability of the AIMS to establish its scope.
Scope Considerations:
- Which AI systems are included (all, or subset by risk level)
- Organizational units involved in AI development, deployment, and use
- Third-party AI systems used by the organization
- Geographic boundaries and regulatory jurisdictions
- Integration with existing management systems (ISO 27001, ISO 9001)
Evidence Required:
- AIMS scope statement document
- AI system inventory within scope
- Justification for any exclusions
Audit Questions:
- What AI systems are included in the AIMS scope?
- Are there AI systems excluded from scope? What is the justification?
- Does the scope cover third-party AI components and services?
4.4 AI Management System
Requirement: Establish, implement, maintain, and continually improve the AIMS in accordance with the standard.
Evidence Required:
- AIMS manual or integrated documentation
- Process maps for AIMS
- Continual improvement records
---
Clause 5 — Leadership
5.1 Leadership and Commitment
Requirement: Top management shall demonstrate leadership and commitment with respect to the AIMS.
Demonstration Methods:
- Allocating adequate resources (budget, personnel, compute, data)
- Establishing AI policy and objectives
- Integrating AIMS requirements into business processes
- Promoting continual improvement and responsible AI
- Supporting other relevant management roles
- Communicating the importance of effective AI governance
Evidence Required:
- Management meeting minutes showing AI governance topics
- Resource allocation records (budget, headcount)
- Management communications on AI policy
Audit Questions:
- How does top management demonstrate commitment to the AIMS?
- What resources have been allocated for AI governance?
- How is AI governance integrated into business strategy?
Common Findings:
- Management commitment is stated but not substantiated with resource allocation
- AI governance is delegated without management oversight
- No regular management review of AIMS effectiveness
5.2 Policy
Requirement: Establish an AI policy that is appropriate, provides a framework for objectives, includes commitment to satisfy requirements, and includes commitment to continual improvement.
AI Policy Must Include:
- Commitment to responsible and ethical AI development and use
- Principles for fairness, transparency, safety, privacy, and accountability
- Alignment with organizational values and applicable regulations
- Framework for setting and reviewing AI objectives
- Commitment to continual improvement of the AIMS
- Commitment to satisfying applicable regulatory requirements
- Statement on human oversight of AI decisions
Evidence Required:
- Documented AI policy signed by top management
- Communication records (email, intranet, training)
- Policy review records
Audit Questions:
- Does the AI policy cover responsible AI principles?
- How is the policy communicated across the organization?
- When was the policy last reviewed and updated?
- Do employees understand and apply the policy?
5.3 Organizational Roles, Responsibilities, and Authorities
Requirement: Ensure responsibilities and authorities for relevant roles are assigned, communicated, and understood.
Key Roles:
| Role | Responsibility |
|---|---|
| AIMS Management Representative | Overall AIMS effectiveness, reporting to management |
| AI Governance Board | Strategic oversight, policy decisions, risk appetite |
| AI System Owner | Accountable for individual AI system performance and compliance |
| Data Steward | Data quality, governance, privacy for AI data |
| AI Ethics Officer/Board | Ethical review of AI applications |
| AI Risk Manager | AI-specific risk assessment and treatment |
| Model Validator | Independent model validation and testing |
| Incident Manager | AI incident response and management |
Evidence Required:
- Organizational chart with AIMS roles
- Role descriptions with authorities
- Appointment records
---
Clause 6 — Planning
6.1 Actions to Address Risks and Opportunities
Requirement: Determine risks and opportunities relevant to the AIMS and plan actions to address them.
AI-Specific Risk Categories:
| Category | Risk Examples |
|---|---|
| Technical | Model failure, data quality issues, adversarial attacks, drift, hallucination |
| Ethical | Bias, discrimination, lack of explainability, autonomy erosion |
| Legal | Regulatory non-compliance, liability, IP infringement, contract breach |
| Societal | Job displacement, misinformation, environmental impact, public trust erosion |
| Organizational | Skill gaps, vendor lock-in, shadow AI, reputational damage |
| Security | Data poisoning, model extraction, prompt injection, unauthorized access |
Risk Assessment Methodology Must Define:
- Risk identification process (how risks are discovered)
- Risk analysis (likelihood and impact assessment criteria)
- Risk evaluation (risk acceptance criteria and thresholds)
- Risk treatment options (Avoid, Mitigate, Transfer, Accept)
- Risk ownership and accountability
- Risk review frequency
Evidence Required:
- Risk assessment methodology document
- Risk register with AI-specific risks
- Risk treatment plans
- Risk acceptance records
6.2 AI Management System Objectives and Planning to Achieve Them
Requirement: Establish measurable AI objectives and plan how to achieve them.
Example AI Objectives:
| Objective | Metric | Target | Timeline |
|---|---|---|---|
| Bias reduction | Demographic parity difference | < 0.05 | 6 months |
| Transparency | % of AI decisions with explanations | 100% for high-risk | Q2 |
| Incident reduction | AI incidents per quarter | < 2 | Ongoing |
| Compliance | Regulatory requirements met | 100% | Ongoing |
| Literacy | Employees completing AI training | > 90% | Annual |
Evidence Required:
- Documented AI objectives (SMART criteria)
- Plans to achieve objectives (who, what, when, resources)
- Monitoring and measurement records
---
Clause 7 — Support
7.1 Resources
AI-Specific Resources:
- Compute: GPU/TPU capacity, cloud resources, training infrastructure
- Data: Training datasets, evaluation datasets, production data pipelines
- Expertise: Data scientists, ML engineers, AI ethics specialists, domain experts
- Tools: ML platforms, monitoring tools, testing frameworks, version control
- Infrastructure: Development environments, staging, production, backup
7.2 Competence
Required Competencies:
| Role Type | Competencies |
|---|---|
| AI developers | ML fundamentals, data engineering, model evaluation, responsible AI |
| AI operators | Deployment, monitoring, incident response, performance tuning |
| Business users | AI literacy, limitations awareness, human oversight practices |
| Governance | Risk assessment, regulatory compliance, ethical evaluation |
| Data management | Data quality, privacy, governance, bias assessment |
Evidence Required:
- Competence requirements per role
- Training records and certifications
- Competence evaluation results
7.3 Awareness
All relevant persons must be aware of:
- The AI policy
- Their contribution to AIMS effectiveness
- Implications of not conforming to AIMS requirements
- Responsible AI principles and their practical application
7.5 Documented Information
Required Documented Information:
| Document | Clause | Type |
|---|---|---|
| AI policy | 5.2 | Maintained |
| AIMS scope | 4.3 | Maintained |
| Risk assessment methodology | 6.1 | Maintained |
| Risk assessment results | 6.1, 8.2 | Retained |
| AI objectives | 6.2 | Maintained |
| Competence evidence | 7.2 | Retained |
| Operational procedures | 8.1 | Maintained |
| Impact assessments | 8.2, A.5 | Retained |
| AI lifecycle records | 8.4, A.6 | Retained |
| Monitoring results | 9.1 | Retained |
| Internal audit results | 9.2 | Retained |
| Management review records | 9.3 | Retained |
| Nonconformity records | 10.1 | Retained |
| Statement of Applicability | Annex A | Maintained |
---
Clause 8 — Operation
8.1 Operational Planning and Control
Requirement: Plan, implement, and control processes needed to meet requirements and implement actions from Clause 6.
8.2 AI Risk Assessment
Requirement: Perform AI risk assessments at planned intervals or when significant changes are proposed.
When to Conduct Risk Assessment:
- Before developing a new AI system
- Before deploying an AI system to production
- When significant changes are made to an AI system
- After an AI incident
- At planned intervals (annually minimum)
- When the external context changes materially
8.3 AI Risk Treatment
Treatment Options:
| Option | When to Apply | Example |
|---|---|---|
| Avoid | Risk exceeds appetite, no viable mitigation | Discontinue high-risk AI application |
| Mitigate | Risk can be reduced to acceptable level | Add human oversight, improve data quality |
| Transfer | Risk better managed by another party | Insurance, contractual allocation |
| Accept | Residual risk within appetite after treatment | Document acceptance rationale |
8.4 AI System Lifecycle
See: ai-lifecycle-management.md for detailed lifecycle guidance.
Evidence Required:
- Lifecycle procedures per stage
- Design records (requirements, architecture, ethical review)
- Development records (data preparation, model training, code review)
- Testing records (functional, bias, robustness, performance)
- Deployment records (approval, staging, monitoring setup)
- Operational records (monitoring logs, performance reports)
- Retirement records (decommissioning plan, data disposal)
---
Clause 9 — Performance Evaluation
9.1 Monitoring, Measurement, Analysis, and Evaluation
AI Performance Metrics to Monitor:
| Category | Metrics |
|---|---|
| Accuracy | Precision, recall, F1-score, AUROC, RMSE (as applicable) |
| Fairness | Demographic parity, equalized odds, disparate impact ratio |
| Reliability | Uptime, response time, throughput, error rate |
| Drift | Data drift (PSI, KS test), concept drift, prediction drift |
| Safety | Incident count, near-miss count, harm severity |
| Compliance | Regulatory requirements met, audit findings |
| User satisfaction | Complaints, feedback scores, adoption rates |
9.2 Internal Audit
Audit Program Requirements:
- Planned intervals (annually minimum)
- Covers all AIMS clauses and applicable Annex A controls
- Auditor independence from area being audited
- Audit criteria, scope, frequency, and methods defined
- Results reported to relevant management
Audit Evidence Checklist:
- [ ] AIMS scope and policy documents
- [ ] Risk assessments and treatment plans
- [ ] AI system inventory and lifecycle records
- [ ] Competence and training records
- [ ] Monitoring and measurement results
- [ ] Incident and nonconformity records
- [ ] Management review minutes
- [ ] Statement of Applicability
9.3 Management Review
Inputs to Management Review:
- Status of actions from previous reviews
- Changes in internal/external issues
- AI system performance and trends
- Audit results
- Nonconformities and corrective actions
- Monitoring and measurement results
- AI incident reports
- Interested party feedback
- Opportunities for improvement
Outputs from Management Review:
- Decisions on improvement opportunities
- Changes to AIMS (scope, policy, objectives)
- Resource allocation decisions
- Risk appetite adjustments
---
Clause 10 — Improvement
10.1 Nonconformity and Corrective Action
Process: 1. Identify nonconformity 2. React to control and correct it 3. Evaluate need for action to eliminate cause 4. Implement corrective action 5. Review effectiveness 6. Update risks and opportunities if needed 7. Make changes to AIMS if needed
10.2 Continual Improvement
Improvement Sources:
- Internal audit findings
- Management review outputs
- AI incident lessons learned
- Industry best practice evolution
- Regulatory changes
- Technology advancement
- Stakeholder feedback
10.3 AI Incident Management (AI-Specific)
Incident Types:
- Model producing biased or discriminatory outputs
- Unexpected model behavior or hallucination
- Data breach involving AI training/inference data
- AI system causing harm (physical, financial, psychological)
- Adversarial attack on AI system
- AI system producing unsafe outputs
- Significant performance degradation
Incident Management Process: 1. Detection and reporting 2. Classification (severity, impact, scope) 3. Containment (disable, rollback, human override) 4. Investigation (root cause analysis) 5. Resolution and recovery 6. Communication to interested parties 7. Lessons learned and preventive actions 8. Documentation and evidence preservation
---
Annex A Controls
A.2 — AI Policies
Objective: Provide management direction and support for AI in accordance with business requirements and applicable laws.
Requirements:
- Define policies for AI development, deployment, and use
- Include responsible AI principles (fairness, transparency, safety, privacy)
- Approve policies at management level
- Communicate to all relevant persons
- Review at planned intervals
Evidence: AI policy document, communication records, review records
Audit Questions:
- Is there a documented AI policy?
- Does it cover responsible AI principles?
- Is it communicated to all employees involved with AI?
- When was it last reviewed?
A.3 — Internal Organization for AI
Objective: Establish a management framework to initiate and control AI implementation.
Requirements:
- Define roles and responsibilities for AI governance
- Implement segregation of duties (development vs. validation vs. deployment)
- Establish AI governance committee or board
- Define escalation and decision-making authority
Evidence: Org chart, role descriptions, governance charter, meeting minutes
A.4 — Resources for AI Systems
Objective: Achieve and maintain appropriate protection and management of resources.
Requirements:
- Identify and provide resources for each AI system
- Manage compute, data, and expertise resources
- Plan for resource scaling and capacity
- Address resource dependencies and single points of failure
Evidence: Resource inventory, capacity plans, budget allocation
A.5 — Assessing AI System Impact
Objective: Identify and evaluate impacts of AI systems on individuals and society.
Requirements:
- Establish impact assessment process
- Conduct assessments before deployment and periodically thereafter
- Evaluate fairness, safety, privacy, transparency, and societal impact
- Document assessment results and treatment decisions
- Review when systems change materially
Evidence: Impact assessment procedure, completed assessments, treatment records
A.6 — AI System Lifecycle
Objective: Ensure controls throughout the AI system lifecycle.
Requirements:
- Define lifecycle stages and gates
- Implement design, development, testing, deployment, monitoring, and retirement controls
- Version control for models and data
- Change management procedures
- Testing and validation requirements
Evidence: Lifecycle procedure, stage-gate records, version history, test results
A.7 — Data for AI Systems
Objective: Ensure appropriate management of data used in AI systems.
Requirements:
- Data quality assessment and improvement
- Data provenance and lineage tracking
- Bias assessment for training and evaluation data
- Data governance and access controls
- Personal data protection measures
- Data retention and disposal
- Data labeling quality assurance
Evidence: Data governance policy, quality reports, provenance records, bias assessments
A.8 — Information for Interested Parties
Objective: Provide appropriate transparency about AI systems.
Requirements:
- Disclose use of AI to affected individuals
- Provide information about AI system capabilities and limitations
- Enable meaningful human oversight
- Publish transparency reports or model cards
- Communicate AI-related incidents to affected parties
Evidence: Disclosure mechanisms, model cards, transparency reports, incident communications
A.9 — Use of AI Systems
Objective: Ensure responsible use of AI systems.
Requirements:
- Define acceptable use policies for AI systems
- Implement human oversight mechanisms
- Provide user guidance and training
- Monitor use for compliance with acceptable use
- Prevent misuse through technical and organizational controls
Evidence: Acceptable use policy, human oversight procedures, user guidance, monitoring records
A.10 — Third-Party Relationships
Objective: Manage risks associated with third-party AI components and services.
Requirements:
- Evaluate third-party AI suppliers before engagement
- Include AI-specific requirements in contracts
- Monitor third-party compliance with requirements
- Manage AI supply chain risks
- Conduct due diligence on third-party training data
Evidence: Supplier evaluation records, contracts, monitoring records, due diligence reports
---
Cross-Standard Mapping
ISO 42001 to ISO 27001 Mapping
| ISO 42001 | ISO 27001 | Integration Approach |
|---|---|---|
| 4.1 Context | 4.1 Context | Extend existing context analysis with AI factors |
| 5.2 AI Policy | 5.2 Information Security Policy | Create AI policy referencing/extending security policy |
| 6.1 Risk Assessment | 6.1.2 Risk Assessment | Use same methodology, add AI-specific risk categories |
| 7.5 Documented Info | 7.5 Documented Information | Use same document control system |
| 8.2 AI Risk Assessment | 8.2 Risk Assessment | Extend risk register with AI risks |
| 9.2 Internal Audit | 9.2 Internal Audit | Combine audit programs, add AI audit criteria |
| 9.3 Management Review | 9.3 Management Review | Add AI performance to review inputs |
| A.7 Data for AI | A.8.10-12 Data controls | Extend data controls for AI-specific requirements |
| A.10 Third Party | A.5.19-23 Supplier | Extend supplier management for AI components |
ISO 42001 to ISO 9001 Mapping
| ISO 42001 | ISO 9001 | Integration Approach |
|---|---|---|
| 4.4 AIMS | 4.4 QMS | Integrate AI management into existing QMS |
| 7.1 Resources | 7.1 Resources | Add AI resource requirements to resource planning |
| 7.2 Competence | 7.2 Competence | Add AI competence to training program |
| 8.1 Operational Planning | 8.1 Operational Planning | Include AI processes in operational planning |
| 9.1 Monitoring | 9.1 Monitoring | Add AI metrics to quality measurement |
| 10.1 Nonconformity | 10.1 Nonconformity | Use same CAPA process for AI nonconformities |
---
EU AI Act Alignment
High-Risk AI Systems (Articles 6-15, 17)
| EU AI Act Requirement | ISO 42001 Mapping | Implementation Guidance |
|---|---|---|
| Risk management system (Art. 9) | 6.1, 8.2, 8.3, A.5 | Use ISO 42001 risk framework to satisfy Art. 9 |
| Data governance (Art. 10) | A.7 | Data quality, bias assessment, provenance per A.7 |
| Technical documentation (Art. 11) | 7.5, A.6 | Lifecycle documentation satisfies Art. 11 + Annex IV |
| Record-keeping (Art. 12) | 7.5, 9.1 | Audit trails and monitoring records |
| Transparency (Art. 13) | A.8 | Stakeholder information and disclosure |
| Human oversight (Art. 14) | A.9 | Human oversight mechanisms per A.9 |
| Accuracy, robustness, cybersecurity (Art. 15) | 9.1, A.6 | Performance monitoring and lifecycle controls |
| Quality management system (Art. 17) | Full AIMS | ISO 42001 AIMS satisfies Art. 17 QMS requirement |
| Conformity assessment (Art. 43) | 9.2, Certification | Internal audit + certification process |
Using ISO 42001 Certification for EU AI Act Compliance
ISO 42001 certification can support EU AI Act conformity assessment:
- Demonstrates a functioning quality management system (Art. 17)
- Provides evidence of risk management (Art. 9)
- Shows data governance practices (Art. 10)
- Documents human oversight procedures (Art. 14)
Note: ISO 42001 certification alone does not guarantee EU AI Act compliance. Additional technical requirements specific to the AI system must also be met.
#!/usr/bin/env python3
"""
AI Impact Assessor
Generates comprehensive AI impact assessments evaluating fairness,
transparency, safety, privacy, security, and accountability dimensions.
Maps impacts to interested parties and provides risk treatment recommendations.
Usage:
python ai_impact_assessor.py --template > ai_system.json
python ai_impact_assessor.py --input ai_system.json
python ai_impact_assessor.py --input ai_system.json --format markdown --output report.md
python ai_impact_assessor.py --input ai_system.json --output report.json
"""
import argparse
import json
import sys
from datetime import datetime
from typing import Any, Dict, List, Tuple
TEMPLATE = {
"system_info": {
"name": "",
"version": "",
"description": "",
"purpose": "",
"domain": "",
"deployment_status": "",
"owner": "",
"assessment_date": ""
},
"model_details": {
"model_type": "",
"training_approach": "",
"is_generative": False,
"is_foundation_model": False,
"is_fine_tuned": False,
"makes_autonomous_decisions": False,
"human_in_the_loop": False,
"decision_impact_level": "",
"affected_population_size": 0
},
"data_details": {
"training_data_sources": [],
"training_data_size": "",
"includes_personal_data": False,
"personal_data_categories": [],
"includes_sensitive_data": False,
"sensitive_data_categories": [],
"data_consent_obtained": False,
"data_quality_assessed": False,
"bias_assessment_conducted": False,
"data_provenance_documented": False,
"data_retention_defined": False,
"anonymization_applied": False
},
"fairness": {
"protected_attributes_identified": False,
"protected_attributes_list": [],
"bias_testing_conducted": False,
"demographic_parity_measured": False,
"equalized_odds_measured": False,
"disparate_impact_assessed": False,
"fairness_thresholds_defined": False,
"bias_mitigation_applied": False,
"ongoing_fairness_monitoring": False,
"redress_mechanism_available": False
},
"transparency": {
"model_documentation_exists": False,
"model_card_published": False,
"decision_explanation_available": False,
"explainability_method_used": "",
"users_informed_of_ai_use": False,
"limitations_documented": False,
"confidence_scores_provided": False,
"audit_trail_maintained": False,
"source_attribution_provided": False,
"algorithmic_logic_disclosed": False
},
"safety": {
"failure_modes_identified": False,
"failure_mode_count": 0,
"edge_cases_tested": False,
"robustness_testing_conducted": False,
"human_override_available": False,
"fallback_mechanism_exists": False,
"safety_critical_application": False,
"harm_potential_assessed": False,
"physical_harm_possible": False,
"psychological_harm_possible": False,
"financial_harm_possible": False,
"kill_switch_available": False,
"performance_degradation_monitoring": False,
"rollback_capability": False
},
"privacy": {
"privacy_impact_assessment_done": False,
"gdpr_applicable": False,
"ccpa_applicable": False,
"data_minimization_practiced": False,
"purpose_limitation_enforced": False,
"consent_mechanisms_implemented": False,
"data_subject_rights_supported": False,
"data_deletion_capability": False,
"encryption_at_rest": False,
"encryption_in_transit": False,
"access_controls_implemented": False,
"differential_privacy_used": False,
"federated_learning_used": False
},
"security": {
"threat_model_created": False,
"adversarial_testing_conducted": False,
"model_integrity_verified": False,
"input_validation_implemented": False,
"output_filtering_implemented": False,
"prompt_injection_mitigated": False,
"model_extraction_mitigated": False,
"data_poisoning_mitigated": False,
"access_management_implemented": False,
"api_rate_limiting": False,
"audit_logging_enabled": False,
"incident_response_plan": False,
"model_versioning_controlled": False
},
"accountability": {
"decision_ownership_defined": False,
"escalation_procedures_exist": False,
"audit_trail_complete": False,
"regulatory_compliance_verified": False,
"ethics_review_conducted": False,
"stakeholder_consultation_done": False,
"complaint_mechanism_available": False,
"liability_framework_defined": False,
"documentation_up_to_date": False,
"periodic_review_scheduled": False
},
"interested_parties": [
{
"party": "",
"relationship": "",
"impact_type": "",
"impact_severity": ""
}
],
"existing_controls": [],
"eu_ai_act_context": {
"risk_category": "",
"is_high_risk": False,
"is_gpai": False,
"is_prohibited": False
}
}
DIMENSION_WEIGHTS = {
"fairness": 0.20,
"transparency": 0.15,
"safety": 0.25,
"privacy": 0.15,
"security": 0.15,
"accountability": 0.10
}
def score_dimension(data: Dict, dimension: str, checks: List[Tuple[str, str, float]]) -> Tuple[float, str, List[Dict]]:
"""Score a dimension and return score, risk level, and findings."""
section = data.get(dimension, {})
findings = []
weighted_total = 0
max_weight = 0
for key, description, weight in checks:
value = section.get(key, False)
max_weight += weight
if value:
weighted_total += weight
findings.append({
"check": description,
"status": "pass" if value else "fail",
"weight": weight,
"dimension": dimension
})
score = (weighted_total / max_weight * 100) if max_weight > 0 else 0
if score >= 80:
risk_level = "Low"
elif score >= 60:
risk_level = "Medium"
elif score >= 40:
risk_level = "High"
else:
risk_level = "Critical"
return score, risk_level, findings
FAIRNESS_CHECKS = [
("protected_attributes_identified", "Protected attributes identified", 2.0),
("bias_testing_conducted", "Bias testing conducted", 2.0),
("demographic_parity_measured", "Demographic parity measured", 1.5),
("equalized_odds_measured", "Equalized odds measured", 1.5),
("disparate_impact_assessed", "Disparate impact assessed", 1.5),
("fairness_thresholds_defined", "Fairness thresholds defined", 1.0),
("bias_mitigation_applied", "Bias mitigation applied", 2.0),
("ongoing_fairness_monitoring", "Ongoing fairness monitoring", 1.5),
("redress_mechanism_available", "Redress mechanism available for affected individuals", 1.0),
]
TRANSPARENCY_CHECKS = [
("model_documentation_exists", "Model documentation exists", 2.0),
("model_card_published", "Model card published", 1.0),
("decision_explanation_available", "Decision explanation available to users", 2.0),
("users_informed_of_ai_use", "Users informed of AI use", 2.0),
("limitations_documented", "Limitations and known issues documented", 1.5),
("confidence_scores_provided", "Confidence scores provided with outputs", 1.0),
("audit_trail_maintained", "Audit trail maintained for decisions", 1.5),
("source_attribution_provided", "Source attribution provided (if applicable)", 0.5),
("algorithmic_logic_disclosed", "Algorithmic logic disclosed to stakeholders", 1.0),
]
SAFETY_CHECKS = [
("failure_modes_identified", "Failure modes identified and documented", 2.0),
("edge_cases_tested", "Edge cases tested", 1.5),
("robustness_testing_conducted", "Robustness/stress testing conducted", 1.5),
("human_override_available", "Human override available for decisions", 2.0),
("fallback_mechanism_exists", "Fallback mechanism exists for failures", 2.0),
("harm_potential_assessed", "Harm potential assessed", 2.0),
("kill_switch_available", "Kill switch / emergency stop available", 1.5),
("performance_degradation_monitoring", "Performance degradation monitoring", 1.5),
("rollback_capability", "Rollback capability to previous version", 1.0),
]
PRIVACY_CHECKS = [
("privacy_impact_assessment_done", "Privacy impact assessment completed", 2.0),
("data_minimization_practiced", "Data minimization practiced", 1.5),
("purpose_limitation_enforced", "Purpose limitation enforced", 1.5),
("consent_mechanisms_implemented", "Consent mechanisms implemented", 1.5),
("data_subject_rights_supported", "Data subject rights supported", 1.5),
("data_deletion_capability", "Data deletion capability", 1.0),
("encryption_at_rest", "Encryption at rest", 1.5),
("encryption_in_transit", "Encryption in transit", 1.5),
("access_controls_implemented", "Access controls implemented", 1.5),
]
SECURITY_CHECKS = [
("threat_model_created", "Threat model created", 2.0),
("adversarial_testing_conducted", "Adversarial testing conducted", 1.5),
("model_integrity_verified", "Model integrity verified", 1.5),
("input_validation_implemented", "Input validation implemented", 1.5),
("output_filtering_implemented", "Output filtering implemented", 1.0),
("prompt_injection_mitigated", "Prompt injection mitigated (if applicable)", 1.0),
("data_poisoning_mitigated", "Data poisoning risks mitigated", 1.0),
("access_management_implemented", "Access management implemented", 1.5),
("audit_logging_enabled", "Audit logging enabled", 1.5),
("incident_response_plan", "Incident response plan for AI security events", 1.5),
("model_versioning_controlled", "Model versioning controlled", 1.0),
]
ACCOUNTABILITY_CHECKS = [
("decision_ownership_defined", "Decision ownership defined", 2.0),
("escalation_procedures_exist", "Escalation procedures exist", 1.5),
("audit_trail_complete", "Audit trail complete", 1.5),
("regulatory_compliance_verified", "Regulatory compliance verified", 2.0),
("ethics_review_conducted", "Ethics review conducted", 1.5),
("stakeholder_consultation_done", "Stakeholder consultation done", 1.0),
("complaint_mechanism_available", "Complaint mechanism available", 1.0),
("liability_framework_defined", "Liability framework defined", 1.0),
("documentation_up_to_date", "Documentation up to date", 1.0),
("periodic_review_scheduled", "Periodic review scheduled", 1.0),
]
def generate_risk_treatments(dimension: str, risk_level: str, findings: List[Dict]) -> List[Dict]:
"""Generate risk treatment recommendations for a dimension."""
treatments = []
failed = [f for f in findings if f["status"] == "fail"]
treatment_map = {
"fairness": {
"protected_attributes_identified": {
"action": "Identify and document all protected attributes relevant to the AI system",
"type": "Mitigate",
"priority": "High",
"effort": "Low"
},
"bias_testing_conducted": {
"action": "Conduct comprehensive bias testing using standard fairness metrics",
"type": "Mitigate",
"priority": "Critical",
"effort": "Medium"
},
"bias_mitigation_applied": {
"action": "Apply bias mitigation techniques (pre-processing, in-processing, or post-processing)",
"type": "Mitigate",
"priority": "Critical",
"effort": "High"
},
"ongoing_fairness_monitoring": {
"action": "Implement continuous fairness monitoring in production",
"type": "Mitigate",
"priority": "High",
"effort": "Medium"
},
},
"transparency": {
"model_documentation_exists": {
"action": "Create comprehensive model documentation including architecture, training, and limitations",
"type": "Mitigate",
"priority": "Critical",
"effort": "Medium"
},
"users_informed_of_ai_use": {
"action": "Implement clear disclosure to users that they are interacting with AI",
"type": "Mitigate",
"priority": "Critical",
"effort": "Low"
},
"decision_explanation_available": {
"action": "Implement explainability mechanism (SHAP, LIME, attention visualization)",
"type": "Mitigate",
"priority": "High",
"effort": "High"
},
},
"safety": {
"failure_modes_identified": {
"action": "Conduct failure mode and effects analysis (FMEA) for the AI system",
"type": "Mitigate",
"priority": "Critical",
"effort": "Medium"
},
"human_override_available": {
"action": "Implement human override mechanism for all AI decisions",
"type": "Mitigate",
"priority": "Critical",
"effort": "Medium"
},
"fallback_mechanism_exists": {
"action": "Design and implement fallback mechanism for AI system failures",
"type": "Mitigate",
"priority": "Critical",
"effort": "Medium"
},
"harm_potential_assessed": {
"action": "Assess potential for physical, psychological, and financial harm",
"type": "Mitigate",
"priority": "Critical",
"effort": "Low"
},
},
"privacy": {
"privacy_impact_assessment_done": {
"action": "Conduct Privacy Impact Assessment (PIA) / DPIA",
"type": "Mitigate",
"priority": "Critical",
"effort": "Medium"
},
"data_minimization_practiced": {
"action": "Review and minimize data collection to what is strictly necessary",
"type": "Mitigate",
"priority": "High",
"effort": "Medium"
},
"encryption_at_rest": {
"action": "Implement encryption at rest for all data stores",
"type": "Mitigate",
"priority": "High",
"effort": "Medium"
},
},
"security": {
"threat_model_created": {
"action": "Create AI-specific threat model covering adversarial attacks, data poisoning, model extraction",
"type": "Mitigate",
"priority": "Critical",
"effort": "Medium"
},
"adversarial_testing_conducted": {
"action": "Conduct adversarial robustness testing",
"type": "Mitigate",
"priority": "High",
"effort": "High"
},
"incident_response_plan": {
"action": "Develop AI-specific incident response plan",
"type": "Mitigate",
"priority": "Critical",
"effort": "Medium"
},
},
"accountability": {
"decision_ownership_defined": {
"action": "Assign clear ownership for AI system decisions and outcomes",
"type": "Mitigate",
"priority": "Critical",
"effort": "Low"
},
"regulatory_compliance_verified": {
"action": "Verify compliance with applicable regulations (EU AI Act, GDPR, sector-specific)",
"type": "Mitigate",
"priority": "Critical",
"effort": "High"
},
"ethics_review_conducted": {
"action": "Conduct ethics review with diverse stakeholder representation",
"type": "Mitigate",
"priority": "High",
"effort": "Medium"
},
}
}
dim_treatments = treatment_map.get(dimension, {})
for finding in failed:
check_key = None
for key, desc, _ in (FAIRNESS_CHECKS + TRANSPARENCY_CHECKS + SAFETY_CHECKS +
PRIVACY_CHECKS + SECURITY_CHECKS + ACCOUNTABILITY_CHECKS):
if desc == finding["check"]:
check_key = key
break
if check_key and check_key in dim_treatments:
treatments.append(dim_treatments[check_key])
elif check_key:
treatments.append({
"action": f"Address: {finding['check']}",
"type": "Mitigate",
"priority": "Medium",
"effort": "Medium"
})
return treatments
def map_eu_ai_act(data: Dict) -> Dict:
"""Map assessment to EU AI Act risk categories."""
context = data.get("eu_ai_act_context", {})
safety = data.get("safety", {})
model = data.get("model_details", {})
mapping = {
"declared_risk_category": context.get("risk_category", "Not classified"),
"is_high_risk": context.get("is_high_risk", False),
"is_gpai": context.get("is_gpai", False),
"is_prohibited": context.get("is_prohibited", False),
"relevant_articles": [],
"obligations": []
}
if context.get("is_prohibited"):
mapping["relevant_articles"].append("Article 5 — Prohibited AI practices")
mapping["obligations"].append("System must not be deployed — falls under prohibited practices")
if context.get("is_high_risk"):
mapping["relevant_articles"].extend([
"Article 9 — Risk management system",
"Article 10 — Data and data governance",
"Article 11 — Technical documentation",
"Article 13 — Transparency and provision of information",
"Article 14 — Human oversight",
"Article 15 — Accuracy, robustness and cybersecurity",
"Article 17 — Quality management system"
])
mapping["obligations"].extend([
"Implement risk management system throughout AI lifecycle",
"Ensure data governance for training, validation, and testing datasets",
"Maintain technical documentation per Annex IV",
"Provide transparency information to deployers",
"Enable effective human oversight",
"Achieve appropriate accuracy, robustness, and cybersecurity",
"Establish quality management system"
])
if context.get("is_gpai"):
mapping["relevant_articles"].extend([
"Article 53 — Obligations for providers of GPAI models",
"Article 55 — Obligations for systemic risk GPAI"
])
mapping["obligations"].extend([
"Maintain technical documentation",
"Provide information to downstream providers",
"Comply with copyright Directive",
"Publish summary of training data"
])
return mapping
def map_iso42001_controls(dimension_scores: Dict) -> List[Dict]:
"""Map assessment results to ISO 42001 Annex A controls."""
control_mapping = []
annex_map = {
"fairness": [
{"control": "A.5", "title": "Assessing AI System Impact",
"relevance": "Fairness assessment is core to impact evaluation"},
{"control": "A.7", "title": "Data for AI Systems",
"relevance": "Data bias assessment directly affects fairness"}
],
"transparency": [
{"control": "A.8", "title": "Information for Interested Parties",
"relevance": "Transparency disclosures for stakeholders"},
{"control": "A.9", "title": "Use of AI Systems",
"relevance": "User guidance and acceptable use documentation"}
],
"safety": [
{"control": "A.6", "title": "AI System Lifecycle",
"relevance": "Safety controls across design, testing, deployment"},
{"control": "A.5", "title": "Assessing AI System Impact",
"relevance": "Safety impact assessment for individuals and society"}
],
"privacy": [
{"control": "A.7", "title": "Data for AI Systems",
"relevance": "Data protection and governance"},
{"control": "A.2", "title": "AI Policies",
"relevance": "Privacy policies for AI data handling"}
],
"security": [
{"control": "A.4", "title": "Resources for AI Systems",
"relevance": "Secure infrastructure and resource management"},
{"control": "A.6", "title": "AI System Lifecycle",
"relevance": "Security controls in development and deployment"}
],
"accountability": [
{"control": "A.3", "title": "Internal Organization for AI",
"relevance": "Organizational roles and accountability structure"},
{"control": "A.10", "title": "Third-Party Relationships",
"relevance": "Accountability in supplier and partner relationships"}
]
}
for dimension, score_data in dimension_scores.items():
controls = annex_map.get(dimension, [])
for ctrl in controls:
control_mapping.append({
"dimension": dimension,
"dimension_risk_level": score_data["risk_level"],
"iso42001_control": ctrl["control"],
"control_title": ctrl["title"],
"relevance": ctrl["relevance"]
})
return control_mapping
def run_assessment(data: Dict) -> Dict:
"""Run full AI impact assessment."""
results = {
"assessment_date": datetime.now().isoformat(),
"framework": "ISO 42001:2023 AI Impact Assessment",
"system": data.get("system_info", {}),
"model": data.get("model_details", {}),
"dimensions": {},
"overall_risk_score": 0.0,
"overall_risk_level": "",
"interested_parties_impact": [],
"risk_treatments": {},
"eu_ai_act_mapping": {},
"iso42001_control_mapping": [],
"summary": {
"high_risk_dimensions": [],
"critical_findings_count": 0,
"recommendations": []
}
}
dimension_configs = [
("fairness", FAIRNESS_CHECKS),
("transparency", TRANSPARENCY_CHECKS),
("safety", SAFETY_CHECKS),
("privacy", PRIVACY_CHECKS),
("security", SECURITY_CHECKS),
("accountability", ACCOUNTABILITY_CHECKS)
]
dimension_scores = {}
weighted_sum = 0
for dim_name, checks in dimension_configs:
score, risk_level, findings = score_dimension(data, dim_name, checks)
treatments = generate_risk_treatments(dim_name, risk_level, findings)
dimension_scores[dim_name] = {
"score": round(score, 1),
"risk_level": risk_level
}
results["dimensions"][dim_name] = {
"score": round(score, 1),
"risk_level": risk_level,
"findings": findings
}
results["risk_treatments"][dim_name] = treatments
weighted_sum += score * DIMENSION_WEIGHTS.get(dim_name, 0)
if risk_level in ("High", "Critical"):
results["summary"]["high_risk_dimensions"].append({
"dimension": dim_name,
"score": round(score, 1),
"risk_level": risk_level
})
results["overall_risk_score"] = round(weighted_sum, 1)
if weighted_sum >= 80:
results["overall_risk_level"] = "Low"
elif weighted_sum >= 60:
results["overall_risk_level"] = "Medium"
elif weighted_sum >= 40:
results["overall_risk_level"] = "High"
else:
results["overall_risk_level"] = "Critical"
# Interested parties impact
for party in data.get("interested_parties", []):
if party.get("party"):
results["interested_parties_impact"].append(party)
# EU AI Act mapping
results["eu_ai_act_mapping"] = map_eu_ai_act(data)
# ISO 42001 control mapping
results["iso42001_control_mapping"] = map_iso42001_controls(dimension_scores)
# Count critical findings
for dim_data in results["dimensions"].values():
for finding in dim_data.get("findings", []):
if finding["status"] == "fail" and finding["weight"] >= 2.0:
results["summary"]["critical_findings_count"] += 1
# Recommendations
if results["summary"]["high_risk_dimensions"]:
dims = ", ".join(d["dimension"] for d in results["summary"]["high_risk_dimensions"])
results["summary"]["recommendations"].append(
f"Prioritize risk treatment for high/critical risk dimensions: {dims}"
)
safety = data.get("safety", {})
if safety.get("safety_critical_application") and not safety.get("human_override_available"):
results["summary"]["recommendations"].append(
"URGENT: Safety-critical application without human override — implement immediately"
)
model = data.get("model_details", {})
if model.get("makes_autonomous_decisions") and not model.get("human_in_the_loop"):
results["summary"]["recommendations"].append(
"Autonomous decision-making without human-in-the-loop — assess if human oversight is required"
)
if data.get("eu_ai_act_context", {}).get("is_high_risk"):
results["summary"]["recommendations"].append(
"EU AI Act high-risk classification — ensure compliance with Articles 9-15, 17"
)
return results
def format_text_report(results: Dict) -> str:
"""Format results as human-readable text."""
lines = []
system = results.get("system", {})
lines.append("=" * 70)
lines.append("AI IMPACT ASSESSMENT REPORT")
lines.append("=" * 70)
lines.append(f"System: {system.get('name', 'Unknown')}")
lines.append(f"Version: {system.get('version', 'N/A')}")
lines.append(f"Purpose: {system.get('purpose', 'N/A')}")
lines.append(f"Domain: {system.get('domain', 'N/A')}")
lines.append(f"Assessment Date: {results['assessment_date']}")
lines.append(f"Overall Risk Score: {results['overall_risk_score']}/100")
lines.append(f"Overall Risk Level: {results['overall_risk_level']}")
lines.append("")
# Dimension scores
lines.append("-" * 70)
lines.append("DIMENSION SCORES")
lines.append("-" * 70)
for dim_name, dim_data in results["dimensions"].items():
score = dim_data["score"]
risk = dim_data["risk_level"]
bar_len = int(score / 5)
bar = "#" * bar_len + "." * (20 - bar_len)
risk_marker = {"Low": " ", "Medium": "! ", "High": "!!", "Critical": "XX"}.get(risk, "??")
lines.append(f" [{risk_marker}] {dim_name.title():<20} [{bar}] {score:>5.1f} ({risk})")
lines.append("")
# High risk dimensions
high_risk = results["summary"]["high_risk_dimensions"]
if high_risk:
lines.append("-" * 70)
lines.append("HIGH/CRITICAL RISK DIMENSIONS")
lines.append("-" * 70)
for dim in high_risk:
lines.append(f" [{dim['risk_level'].upper()}] {dim['dimension'].title()} — Score: {dim['score']}")
lines.append("")
# Risk treatments
lines.append("-" * 70)
lines.append("RISK TREATMENT RECOMMENDATIONS")
lines.append("-" * 70)
for dim_name, treatments in results["risk_treatments"].items():
if treatments:
lines.append(f" {dim_name.title()}:")
for t in treatments:
lines.append(f" [{t['priority']}] {t['action']}")
lines.append(f" Type: {t['type']} | Effort: {t['effort']}")
lines.append("")
# EU AI Act
eu_mapping = results.get("eu_ai_act_mapping", {})
if eu_mapping.get("relevant_articles"):
lines.append("-" * 70)
lines.append("EU AI ACT MAPPING")
lines.append("-" * 70)
lines.append(f" Risk Category: {eu_mapping.get('declared_risk_category', 'N/A')}")
lines.append(f" High-Risk: {'Yes' if eu_mapping.get('is_high_risk') else 'No'}")
lines.append(f" GPAI: {'Yes' if eu_mapping.get('is_gpai') else 'No'}")
for art in eu_mapping.get("relevant_articles", []):
lines.append(f" - {art}")
lines.append("")
# Recommendations
recs = results["summary"]["recommendations"]
if recs:
lines.append("-" * 70)
lines.append("RECOMMENDATIONS")
lines.append("-" * 70)
for i, rec in enumerate(recs, 1):
lines.append(f" {i}. {rec}")
lines.append("")
lines.append("=" * 70)
lines.append("End of Report")
lines.append("=" * 70)
return "\n".join(lines)
def format_markdown_report(results: Dict) -> str:
"""Format results as a markdown report."""
system = results.get("system", {})
lines = []
lines.append(f"# AI Impact Assessment: {system.get('name', 'Unknown')}")
lines.append("")
lines.append(f"**Version:** {system.get('version', 'N/A')}")
lines.append(f"**Purpose:** {system.get('purpose', 'N/A')}")
lines.append(f"**Domain:** {system.get('domain', 'N/A')}")
lines.append(f"**Assessment Date:** {results['assessment_date']}")
lines.append(f"**Overall Risk Score:** {results['overall_risk_score']}/100")
lines.append(f"**Overall Risk Level:** {results['overall_risk_level']}")
lines.append("")
# Dimension summary table
lines.append("## Dimension Scores")
lines.append("")
lines.append("| Dimension | Score | Risk Level |")
lines.append("|-----------|-------|------------|")
for dim_name, dim_data in results["dimensions"].items():
lines.append(f"| {dim_name.title()} | {dim_data['score']}/100 | {dim_data['risk_level']} |")
lines.append("")
# Per-dimension details
for dim_name, dim_data in results["dimensions"].items():
lines.append(f"## {dim_name.title()}")
lines.append("")
lines.append(f"**Score:** {dim_data['score']}/100 | **Risk Level:** {dim_data['risk_level']}")
lines.append("")
passed = [f for f in dim_data["findings"] if f["status"] == "pass"]
failed = [f for f in dim_data["findings"] if f["status"] == "fail"]
if passed:
lines.append("**Implemented:**")
for f in passed:
lines.append(f"- [x] {f['check']}")
if failed:
lines.append("")
lines.append("**Gaps:**")
for f in failed:
lines.append(f"- [ ] {f['check']}")
lines.append("")
treatments = results["risk_treatments"].get(dim_name, [])
if treatments:
lines.append("**Risk Treatments:**")
lines.append("")
lines.append("| Priority | Action | Type | Effort |")
lines.append("|----------|--------|------|--------|")
for t in treatments:
lines.append(f"| {t['priority']} | {t['action']} | {t['type']} | {t['effort']} |")
lines.append("")
# EU AI Act
eu_mapping = results.get("eu_ai_act_mapping", {})
if eu_mapping.get("relevant_articles"):
lines.append("## EU AI Act Mapping")
lines.append("")
lines.append(f"- **Risk Category:** {eu_mapping.get('declared_risk_category', 'N/A')}")
lines.append(f"- **High-Risk:** {'Yes' if eu_mapping.get('is_high_risk') else 'No'}")
lines.append(f"- **GPAI:** {'Yes' if eu_mapping.get('is_gpai') else 'No'}")
lines.append("")
if eu_mapping.get("obligations"):
lines.append("**Obligations:**")
for ob in eu_mapping["obligations"]:
lines.append(f"- {ob}")
lines.append("")
# ISO 42001
iso_mapping = results.get("iso42001_control_mapping", [])
if iso_mapping:
lines.append("## ISO 42001 Control Mapping")
lines.append("")
lines.append("| Dimension | Risk | Control | Title | Relevance |")
lines.append("|-----------|------|---------|-------|-----------|")
for m in iso_mapping:
lines.append(
f"| {m['dimension'].title()} | {m['dimension_risk_level']} | "
f"{m['iso42001_control']} | {m['control_title']} | {m['relevance']} |"
)
lines.append("")
# Recommendations
recs = results["summary"]["recommendations"]
if recs:
lines.append("## Recommendations")
lines.append("")
for i, rec in enumerate(recs, 1):
lines.append(f"{i}. {rec}")
lines.append("")
lines.append("---")
lines.append(f"*Generated by AI Impact Assessor (ISO 42001:2023)*")
return "\n".join(lines)
def main():
parser = argparse.ArgumentParser(
description="AI Impact Assessor — generates comprehensive AI system impact "
"assessments per ISO 42001:2023 requirements."
)
parser.add_argument(
"--input", "-i",
help="Path to JSON file describing the AI system"
)
parser.add_argument(
"--template", "-t",
action="store_true",
help="Output a blank AI system template (JSON)"
)
parser.add_argument(
"--output", "-o",
help="Path to write the assessment report"
)
parser.add_argument(
"--json", "-j",
action="store_true",
help="Output results as JSON"
)
parser.add_argument(
"--format", "-f",
choices=["text", "markdown"],
default="text",
help="Output format (default: text)"
)
args = parser.parse_args()
if args.template:
print(json.dumps(TEMPLATE, indent=2))
return
if not args.input:
parser.error("--input is required (or use --template to generate a blank profile)")
try:
with open(args.input, "r") as f:
data = json.load(f)
except FileNotFoundError:
print(f"Error: File not found: {args.input}", file=sys.stderr)
sys.exit(1)
except json.JSONDecodeError as e:
print(f"Error: Invalid JSON in {args.input}: {e}", file=sys.stderr)
sys.exit(1)
results = run_assessment(data)
if args.json:
output = json.dumps(results, indent=2)
elif args.format == "markdown":
output = format_markdown_report(results)
else:
output = format_text_report(results)
if args.output:
with open(args.output, "w") as f:
f.write(output)
print(f"Report written to {args.output}")
else:
print(output)
if __name__ == "__main__":
main()
Related skills
FAQ
What standard does this skill target?
ISO/IEC 42001:2023, the first international standard for AI Management Systems (AIMS).
What does the readiness checker output?
An overall 0-100 readiness score, per-clause maturity levels, Annex A control status, gap analysis, and a certification readiness verdict.