Skip to main content
COMPEL Body of Knowledge
Get Certified Platform
AITE M1.2-Art34 v1.0 Reviewed 2026-04-06 Open Access
M1.2 The COMPEL Six-Stage Lifecycle
AITF · Foundations

Responsible-Agentic-AI Pattern Language

Responsible-Agentic-AI Pattern Language — Transformation Design & Program Architecture — Advanced depth — COMPEL Body of Knowledge.

9 min read Article 34 of 53

The architect’s role here is not to enumerate ethical principles — the stage-gate governance work handles that — but to make those principles instantiable in the agent’s design. A principle without a pattern is a wish; a pattern without a principle is a mechanism. The pattern language gives you both.

The seven patterns

Pattern 1 — Disclosure of autonomy level

Intent: The user and the overseer can always tell what the agent is permitted to do on its own versus what requires human approval.

Structure: The agent’s UI and its API responses disclose the autonomy level (L0–L5, Article 2) and the current autonomy envelope. High-autonomy features are labeled; low-autonomy features carry the affordances for escalation.

Implementation:

  • Every agent UI surface shows an autonomy indicator (“This agent can: answer questions; retrieve documents; draft responses. It cannot: send messages; change account settings.”).
  • EU AI Act Article 50 disclosure is the floor; the pattern exceeds the floor by being specific.
  • Changes to the envelope (expansions, restrictions) are logged and, for customer-facing expansions, announced.

Plugs into: Article 2 (autonomy spectrum); Article 23 (Article 50 transparency).

Pattern 2 — Calibrated confidence

Intent: The agent communicates uncertainty in a way users can act on.

Structure: The agent reports confidence not as a single number but as an appropriate shape: “high / medium / low” plus contributing factors, or probability ranges, or “I’m not sure — here are two possible answers, which one matches your case?”

Implementation:

  • Calibration training or post-hoc calibration so reported confidence tracks actual accuracy.
  • Source citations where confidence is grounded.
  • “I don’t know” as a first-class response class — the agent refuses to guess when evidence is thin.
  • Output classifiers detect over-confident answers to novel questions and gate them.

Plugs into: Article 4 (loop patterns — Reflexion encourages calibrated output); Article 17 (evaluation includes calibration metrics).

Pattern 3 — Explanation surface

Intent: An overseer or an affected person can reconstruct why the agent did what it did.

Structure: Each output carries or links to: the inputs that contributed (user context, retrieved documents, tool outputs, memory entries), the decision rules applied (policy-engine decisions, classifier pass/fail), and the reasoning summary.

Implementation:

  • Trace export from Article 15 observability, filtered for presentability.
  • “Why did you recommend this?” is a first-class affordance, not a support case.
  • For high-stakes decisions (Annex III), the explanation meets the legal-sufficiency bar set by GDPR Article 22 and, where applicable, administrative-law due-process.

Plugs into: Article 15 (observability); Article 23 (Article 14 evidence); Article 28 (data lineage).

Pattern 4 — Contestability

Intent: A person affected by an agent’s action can challenge it and get a human decision.

Structure: Every agent-produced decision or representation that affects a person has a named contest path, a service-level target for first human response, and a documented escalation.

Implementation:

  • Contest path exposed in the UI (“disagree with this? Tell us why and a person will review within 2 business days”).
  • Contest outcomes logged; fed into evaluation (Article 17).
  • Internal dashboard on contest rate, contest-success rate, and time-to-first-human-response.

Plugs into: Article 10 (HITL); Article 32 (public-sector contestability emphasis); GDPR Article 22.

Pattern 5 — Shutdown affordance

Intent: Anyone with legitimate cause can stop the agent without the agent’s cooperation.

Structure: Kill-switch (Article 9) affordances at multiple levels — session, agent class, entire agentic platform — reachable from the UI and from ops tooling, with the agent having no veto.

Implementation:

  • Per-session stop button visible to the user.
  • Per-agent-class kill-switch in ops console with audit log of who pressed and why.
  • Platform-level circuit breaker coupled to deadman signals (Article 9).
  • Drill schedule: the kill-switch is exercised in game-days.

Plugs into: Article 9 (kill-switch); Article 25 (incident response).

Pattern 6 — Refusal design

Intent: The agent refuses in-scope-inappropriate requests with a useful explanation, without being either brittle or compliant-to-everything.

Structure: Refusal is a first-class output; refusals explain the reason at the appropriate level; refusals route the user to an acceptable next step where possible.

Implementation:

  • A curated refusal taxonomy (policy violation, data protection, outside-scope, safety concern).
  • Refusal responses are evaluated — over-refusal rate, under-refusal rate, refusal-clarity score — in the Article 17 battery.
  • Jailbreak-resistance is tested in the adversarial battery without making the agent unhelpful to legitimate users.
  • When the agent refuses, it offers (where possible) the acceptable alternative: “I can’t book travel, but I can draft the request for the concierge.”

Plugs into: Article 8 (guardrails); Article 14 (injection resistance); Article 17 (evaluation).

Pattern 7 — Bystander protection

Intent: People who are not the agent’s user but who are affected by the agent — the recipients of an agent-sent email, the subjects of an agent-generated claim assessment, the students in a classroom using an agent — have their interests considered in the design.

Structure: The design enumerates bystanders; identifies how each could be harmed; builds controls into the interaction with them.

Implementation:

  • Bystander list in the ADR (Article 2).
  • Article 50 disclosure to bystanders when the agent is an outbound-facing actor (email recipients, call recipients).
  • Preference respect — opt-out paths for bystanders; “stop sending me these” works and is honored.
  • Harm pathways mitigated — an agent that scores insurance claims protects subjects from discriminatory features; an agent that moderates content protects contributors from capricious refusals.

Plugs into: Article 10 (HITL), Article 23 (Article 50 disclosure), Article 32 (public-sector due process).

Pattern × architecture matrix

Use-case × pattern fit matrix

Different use cases require different subsets of patterns more urgently.

Composing patterns

Patterns compose well because each attaches to a different architectural surface. Examples:

  • Disclosure + shutdown gives the user control (they know what the agent can do, and they can stop it).
  • Explanation + contestability gives the overseer control (the reasoning is visible, and the decision is challengeable).
  • Calibration + refusal gives the model humility (it knows when it doesn’t know, and it refuses rather than hallucinating).
  • Bystander + contestability gives third parties voice (they are considered in design, and they can push back).

A design that implements one pattern without the others is still valuable but structurally weak; the patterns are meant to be layered.

How to introduce patterns during Calibrate

The architect uses the pattern list as a checklist during Calibrate (Article 36):

  1. For each pattern, is it required, recommended, or inapplicable to this use case?
  2. For each required pattern, what is the concrete architectural artefact? (UI component, classifier, policy rule, runbook entry.)
  3. For each required pattern, who owns the implementation?
  4. For each required pattern, how is compliance measured in evaluation?

This turns “responsible AI” from a conversation into a specification.

Real-world references

Microsoft Responsible AI Standard v2 (2022). Internal Microsoft standard published externally; codifies accountability, transparency, fairness, reliability-and-safety, privacy-and-security, inclusiveness. The patterns in this article map to the Standard’s requirements; the architect uses the Standard vocabulary when working with Microsoft-adjacent stakeholders.

Google AI Principles and implementation documents. Published principles plus periodic implementation updates; the “Be accountable to people” principle maps to contestability + explanation patterns in this article.

Apple Intelligence public safety documentation (2024). Apple’s safety materials emphasize on-device processing, opt-in personal-context use, and narrow scopes — each is an implementation of specific responsible-agentic patterns.

Anthropic’s Acceptable Use Policy and Usage Policies. Anthropic’s published policies and the Constitutional AI technique illustrate refusal design as a first-class capability.

Anti-patterns to reject

  • “Responsible AI is the ethics committee’s problem.” Ethics committees can govern but cannot implement; responsibility lives in the patterns.
  • “We have a fairness test; we’re responsible.” One test is one data point; patterns are durable structure.
  • “Disclosure is in the Terms of Service.” A ToS notice is a legal floor; a disclosure pattern is an ongoing architectural commitment.
  • “Agents refuse when they should; we don’t need a refusal taxonomy.” Without a taxonomy you cannot evaluate and cannot regress-test refusals.
  • “Bystanders aren’t our users.” They are the agent’s counterparts; the harm attribution goes to the operator regardless.

Learning outcomes

  • Explain the seven responsible-agentic patterns, their intent, and the architectural surfaces they attach to.
  • Classify four use cases by required pattern set and identify the one pattern most critical to each.
  • Evaluate a proposed agent design for pattern completeness and pattern composition integrity.
  • Design a pattern package for a given agent including specific UI components, classifiers, policy rules, and monitoring.

Further reading

  • Core Stream anchors: EATF-Level-1/M1.5-Art06-AI-Ethics-Operationalized.md; EATF-Level-1/M1.1-Art10-Ethical-Foundations-of-Enterprise-AI.md.
  • AITE-ATS siblings: Article 8 (guardrails), Article 9 (kill-switch), Article 10 (HITL), Article 17 (evaluation), Article 23 (EU AI Act).
  • Primary sources: Microsoft Responsible AI Standard v2; Google AI Principles; Apple Intelligence public safety documentation; Anthropic Usage Policies and Constitutional AI research.