Lesson 2: Inclusiveness, Transparency and Accountability

Where we are

In Level 1 you learned the first three responsible AI principles: fairness, reliability and safety, and privacy and security. This level covers the other three, inclusiveness, transparency and accountability, and then gives you practice telling all six apart. That skill matters most here. On the exam the scenario questions usually describe something a team does, and you have to name the principle behind it.

A quick reminder: the AI-901 study guide belongs to Microsoft. It is free on Microsoft Learn and is not reproduced in this course. Fundamentals exams give you 45 minutes for the exam itself (65 minutes of seat time), and you need 700 to pass. This course is independent of Microsoft and can't promise you a pass.

Microsoft says transparency and accountability sit underneath the other principles. If you can't explain a system, and nobody owns it, you can't check whether it is fair, safe or private. So learn those two as the foundation.

Inclusiveness: design for everyone, test with everyone

Microsoft's short definition is: design for diverse needs and test with a broad set of users to avoid exclusion. It frames this partly around the more than 1 billion people worldwide with disabilities, for whom features like real-time captions, image recognition and predictive text can transform daily life.

Microsoft's inclusive design principles:

• Recognize exclusion: work out who might be left out, and why.
• Solve for one, extend to many: captions built for deaf users also help everyone watching in a noisy train.
• Learn from diversity: bring in different perspectives.

In practice that means following accessibility laws and standards and including people with disabilities in testing.

Transparency: make the system understandable

Microsoft's definition: make systems intelligible: explain how they work, what they use, and where they might fall short. Microsoft calls the core of this intelligibility, meaning a useful explanation of how the system behaves. It also says people who use AI should be honest about when, why and how they deploy it.

Concrete transparency practices:

• Tell users they are talking to an AI, not a person.
• Share the key characteristics of the datasets you used.
• Explain why a decision came out the way it did ("declined because of income-to-debt ratio").
• Publish known limitations. Microsoft does this for its own AI services in documents called Transparency Notes.
• Train staff to interpret AI outputs.

Accountability: people answer for the system

Microsoft's definition: assign clear ownership, review decisions, and create paths for remediation when things go wrong. The key sentence is that the people who design and deploy AI systems must be accountable for how their systems operate. The model and the vendor don't carry that responsibility for you. AI should not be the final authority on decisions that affect people's lives.

What accountability needs:

• Internal review boards to oversee development and deployment.
• Trained employees who know how to run the system responsibly.
• Humans with the right expertise in the loop, able to inspect and override.
• A clear system of accountability and governance, so problems get fixed.

Walkthrough: one chatbot, three principles in code

Here is a plain-Python wrapper around a loan-support assistant. The model call is a stub, because calling Foundry models comes in later levels. What matters is where each principle shows up.

import datetime, json

AI_DISCLOSURE = "You're chatting with an AI assistant. A human advisor reviews all loan decisions."  # TRANSPARENCY

def fake_model(prompt):           # stand-in for a real deployed model
    return {"answer": "Your application looks likely to be declined.",
            "reason": "debt-to-income ratio above 45%",
            "confidence": 0.62}

AUDIT_LOG = []                    # ACCOUNTABILITY: a record someone can review
OWNER = "loans-ai-team@contoso.example"  # ACCOUNTABILITY: a named owner

def respond(user_msg, prefers_audio=False):
    result = fake_model(user_msg)
    reply = {
        "disclosure": AI_DISCLOSURE,                     # TRANSPARENCY: say it's AI
        "text": result["answer"],
        "why": f"Main factor: {result['reason']}",      # TRANSPARENCY: explain the outcome
        "plain_text_for_screen_readers": True,          # INCLUSIVENESS: no image-only answers
        "offer_audio": prefers_audio,                    # INCLUSIVENESS: speech output option
    }
    # ACCOUNTABILITY: consequential + uncertain -> a human decides, not the model
    if "declined" in result["answer"] or result["confidence"] < 0.8:
        reply["status"] = "pending_human_review"
    AUDIT_LOG.append({"time": datetime.datetime.now().isoformat(),
                      "input": user_msg, "output": reply, "owner": OWNER})
    return reply

print(json.dumps(respond("Will my loan be approved?", prefers_audio=True), indent=2))

Sample output (trimmed):

"disclosure": "You're chatting with an AI assistant. A human advisor reviews all loan decisions.",
"why": "Main factor: debt-to-income ratio above 45%",
"offer_audio": true,
"status": "pending_human_review"

Gotcha from production: an audit log with no named owner who reads it isn't accountability. Lots of teams log everything and review nothing. The exam takes the same view: accountability is about people and governance, not just storing records.

When something goes wrong: the remediation path

Accountability shows up most clearly in what happens after a failure. A sensible order:

1. Detect: through monitoring or a user report.
2. Escalate to the named owner: someone is clearly responsible.
3. Human review: people with the right expertise decide what happened.
4. Remediate and record: fix it, document it, and update practices (often through the review board).

Telling the six apart: a cheat sheet

Worked close call: "A bank's AI tells rejected applicants which factors drove the decision." It's tempting to answer fairness because loans are involved. But nothing here compares groups. The action is explaining, so the answer is transparency. Fairness would be "the bank checks approval rates across age groups with similar finances."

Another one: "Only a human loan officer can finalise a rejection." It isn't reliability (that's about consistent behaviour) and it isn't transparency (nothing is being explained). Humans keeping control is accountability.

For each wrong option, say out loud which principle it does describe. If two options seem to fit, ask: "what is the team actually doing?"

What the exam asks about this

Expect short scenarios along the lines of "which principle does this support?" Watch for these trigger words: screen reader, captions, speech input, people with disabilities → inclusiveness. Tell users it's AI, explain, limitations, documentation → transparency. Review board, governance, human oversight, who is responsible → accountability. Distractors are usually the principle next door: fairness versus transparency, and reliability versus accountability.

Key takeaways

• Inclusiveness: design for diverse needs and test with a broad range of users, including people with disabilities.
• Transparency: make the system intelligible. Disclose AI use, explain outcomes, publish limitations.
• Accountability: the people who design and deploy the system answer for it, through clear ownership, review boards, human oversight and remediation.
• Transparency and accountability are the foundation the other four principles rest on.
• In close calls, name what the team is doing, then match that action to a principle.