WWDC Quick Look đź’“ By SwiftGGTeam
中文 EN 日本語
What's new in assessment on macOS

What's new in assessment on macOS

Automatic Assessment ConfigurationmacOSEducationSecurity
Watch original video

Highlight

macOS 27 expands the Automatic Assessment Configuration framework so education testing apps can configure system-level security checks, accessibility restrictions, Menu Bar and Dock customization, file-access allow lists, and process control through a single API, without writing their own interception code.

Core Content

Checking Device State Before an Exam

(00:40)

When you run an online exam, one of the biggest risks is that students have changed their systems beyond recognition before the test starts. SIP may be off, MDM may have been removed, or Lockdown Mode may be enabled and blocking the network monitoring the exam depends on. Any of these can make the assessment environment untrustworthy.

Previously, developers had to write their own scripts to check these states. The logic was tightly coupled to system versions and could break whenever macOS was updated.

macOS 27 folds these checks into AEAssessmentConfiguration. You set a few Boolean properties, and the system validates them automatically before the exam begins. If a device does not meet the requirements, the system shows a dialog telling the student what to fix, with no UI code required from you.

Accessibility: Preserve by Default, Restrict When Needed

(03:00)

The easiest mistake for exam software is to shut off all accessibility features in one sweep. VoiceOver and Switch Control are essential for students with disabilities; turning them off is effectively denying their right to take the test.

AAC takes the opposite approach: it preserves the accessibility features the student has already enabled by default, and developers explicitly specify which features should be disabled. allowsAccessibilitySwitchControl = true does not turn Switch Control on for a student; it only allows students who already use it to keep using it. This shifts accessibility from “patch it after the exam” to “design it in from day one.”

Customizing the System Experience with an Allow-List Model

(05:07)

Mac users are used to the Menu Bar and Dock. In the past, exam apps often tried to prevent cheating by placing a full-screen borderless window over the entire system UI, leaving students unable to see the time or adjust volume.

Apple’s new approach is not a blanket shutdown. Instead, it provides allow-list APIs. You can precisely control which Menu Bar icons appear, which Apple menu items remain, and whether the Dock is visible. The system renders the native UI, so you do not need to draw fake replacements yourself.

Process Control: Only Trusted Processes May Run

(09:16)

Safari, Notes, and Shortcuts running in the background can all become cheating channels. Screenshots, screen recordings, and automation scripts should not exist during an exam.

allowOnlyParticipantsToRun = true lets the system automatically terminate every non-allow-listed process when the exam begins. Combined with allowsUserScriptExecution = false, which blocks Shortcuts and Automator, the exam environment moves from app-level defense to system-level defense.

Details

System Prerequisite Checks

(02:30)

AEAssessmentConfiguration provides six system-level preflight checks:

import AutomaticAssessmentConfiguration

func makeAssessmentConfiguration() -> AEAssessmentConfiguration {
    let configuration = AEAssessmentConfiguration()

    configuration.allowLockdownMode = false
    configuration.allowPrivateRelay = false
    configuration.requiresSIP = true
    configuration.requiresManagedDevice = true
    configuration.requiresSingleUser = true
    configuration.requiresUserAccountType = .standard

    return configuration
}

Key points:

  • requiresSIP: requires System Integrity Protection to be enabled, preventing low-level system tampering
  • requiresManagedDevice: requires the device to be managed through MDM, suitable for school-issued devices
  • requiresSingleUser: requires only one user account to be logged in, preventing cheating through account switching
  • requiresUserAccountType: restricts the account type to .standard, excluding administrator accounts
  • allowLockdownMode: setting this to false requires Lockdown Mode to be off, so it does not block network monitoring required by the exam
  • allowPrivateRelay: setting this to false requires iCloud Private Relay to be off, so network traffic can be audited

If a student’s device fails any condition, the system automatically shows a prompt listing every issue that must be fixed.

Accessibility Restrictions

(04:01)

import AutomaticAssessmentConfiguration

func makeAssessmentConfiguration() -> AEAssessmentConfiguration {
    let configuration = AEAssessmentConfiguration()

    configuration.allowsAccessibilityVoiceOver = true
    configuration.allowsAccessibilitySwitchControl = false
    configuration.allowsAccessibilityAlternativeInputMethods = true
    configuration.allowsAccessibilityBackgroundSounds = true
    configuration.allowsAccessibilityHoverText = true
    configuration.allowsAccessibilityLiveSpeech = true
    configuration.allowsAccessibilitySpokenContent = true
    configuration.allowsAccessibilityVoiceControl = true
    configuration.allowsAccessibilityZoom = true

    return configuration
}

Key points:

  • Each property with the allowsAccessibility prefix controls one specific accessibility feature
  • Setting a property to true means “allow students who already enabled this feature to keep using it”; it does not turn the feature on for them
  • Setting it to false automatically exits that feature when the exam begins and prevents the student from re-enabling it during the exam
  • Switch Control is disabled here because it can record and replay custom action sequences, which creates a cheating risk
  • VoiceOver, Zoom, Hover Text, and similar visual accessibility features are generally recommended to remain available so students with visual impairments can participate normally

(05:32)

import AutomaticAssessmentConfiguration

func makeAssessmentConfiguration() -> AEAssessmentConfiguration {
    let configuration = AEAssessmentConfiguration()

    configuration.allowsMenuBar = true
    configuration.allowedMenuBarItems = [
        .battery,
        .clock,
        .volume
    ]
    configuration.allowedAppleMenuItems = [
        .sleep
    ]

    return configuration
}

Key points:

  • allowsMenuBar = true enables Menu Bar display; it is hidden by default
  • allowedMenuBarItems is an allow list, so only the listed system icons remain
  • Icons on the allow list are not forced to appear; if the student did not already add that icon to the Menu Bar, it will not appear
  • allowedAppleMenuItems controls the contents shown after clicking the Apple icon in the upper-left corner
  • Passing an empty array hides all Apple menu items except “About This Mac”

Input Method Restrictions

(07:01)

import AutomaticAssessmentConfiguration

func makeAssessmentConfiguration() -> AEAssessmentConfiguration {
    let configuration = AEAssessmentConfiguration()

    configuration.allowsDictation = false
    configuration.allowsAutoFill = false
    configuration.allowsStructuralInput = false
    configuration.allowsEmojiKeyboard = false

    return configuration
}

Key points:

  • allowsDictation: dictation may automatically correct spelling and provide a “free” answer
  • allowsAutoFill: AutoFill can preload information from Contacts and other sources, potentially exposing reference material
  • allowsStructuralInput: structural input can reveal character composition rules and may leak answer clues
  • allowsEmojiKeyboard: the emoji keyboard includes search and can be used as a channel for coded messages
  • These restrictions also hide the corresponding menu items and prevent their use in UI controls that support them

Dock and File System Access

(07:38)

import AutomaticAssessmentConfiguration

func makeAssessmentConfiguration() -> AEAssessmentConfiguration {
    let configuration = AEAssessmentConfiguration()

    configuration.allowsDock = true

    return configuration
}

(08:35)

import AutomaticAssessmentConfiguration

func makeAssessmentConfiguration() -> AEAssessmentConfiguration {
    let configuration = AEAssessmentConfiguration()

    configuration.allowedDirectoriesAndFiles = [
        URL(fileURLWithPath: "~/Documents/")
    ]

    return configuration
}

Key points:

  • allowsDock = true shows the Dock, but only renders apps allowed for the exam; Finder and Trash are always present
  • Even if Finder appears in the Dock, it must be explicitly added as a participant before the student can interact with it
  • allowedDirectoriesAndFiles applies to both standard Open/Save panels and Finder windows
  • When students save files, the Save panel only shows allow-listed directories and cannot browse elsewhere

Process and Script Restrictions

(09:58)

import AutomaticAssessmentConfiguration

func makeAssessmentConfiguration() -> AEAssessmentConfiguration {
    let configuration = AEAssessmentConfiguration()

    configuration.allowOnlyParticipantsToRun = true
    configuration.allowsUserScriptExecution = false

    return configuration
}

Key points:

  • allowOnlyParticipantsToRun = true: when the exam starts, the system terminates all non-allow-listed processes, keeping only the main exam app, explicitly added participant apps, and required system processes
  • allowsUserScriptExecution = false: prevents Shortcuts and Automator scripts from running
  • Background apps such as Safari and Notes automatically quit when the exam begins
  • If the exam depends on third-party components, such as an anti-cheating camera plug-in, those components must be added to the participant allow list first

Best Practices

(10:51)

  • Replace your own interception code with framework APIs. Legacy techniques such as CGEventTap and hidden window overlays can be removed
  • Start permissive, then tighten only as needed. Excessive restrictions harm the test-taking experience
  • Treat accessibility as a requirement, not something to patch after the exam
  • Register transition callbacks and drive app state from system callbacks; do not assume calling begin/end takes effect immediately
  • Test on the day each macOS beta ships, and file Feedback as soon as you find issues

Key Takeaways

Build a “one-click start exam” education app

What to do: Before an exam begins, the app automatically checks device state, configures the environment, and locks down the system. The student only taps “Start Exam”; all security checks and environment setup are handled by the AAC framework.

Why it is worth doing: Previously, developers had to write scripts to check SIP, MDM, Lockdown Mode, and other states. The logic was tightly coupled to system versions and broke easily after macOS updates. AAC standardizes these checks and automatically prompts students to fix noncompliant devices.

How to start: Create an AEAssessmentConfiguration, set properties such as requiresSIP, requiresManagedDevice, and allowLockdownMode, then call begin to start the assessment session.

Create customized exam assistance for students with disabilities

What to do: Use fine-grained accessibility controls to generate different configuration templates for students with different needs. Preserve VoiceOver and Zoom for students with visual impairments, preserve Switch Control for students with motor impairments, and disable other features only when they create cheating risk.

Why it is worth doing: Shutting off all accessibility features denies students with disabilities their right to take the exam. AAC preserves enabled accessibility features by default, while developers disable only the specific items that are risky.

How to start: Generate AEAssessmentConfiguration dynamically from student profiles. Set properties such as allowsAccessibilityVoiceOver and allowsAccessibilitySwitchControl, and load the right template for each student’s needs.

Build an exam environment monitoring dashboard

What to do: Build a real-time dashboard for instructors that shows every student’s device state: whether SIP is enabled, whether unauthorized processes are running, and which accessibility features are active.

Why it is worth doing: Proctors cannot manually inspect every student device, especially in remote exams. AAC preflight capabilities can report compliance status to an instructor system and automatically flag abnormal devices.

How to start: Integrate AAC preflight logic into the exam app, report results to the instructor side through WebSocket or polling APIs, and show device status with red/yellow/green indicators on the dashboard.

Build a secure offline exam mode

What to do: Use allowOnlyParticipantsToRun and file system allow lists to create a fully offline assessment environment. During the exam, students can access only specified local resources.

Why it is worth doing: Background apps such as Safari, Notes, and Shortcuts can all become cheating channels. Process control upgrades the assessment environment from app-level defense to system-level defense and automatically terminates every non-allow-listed process.

How to start: Set allowOnlyParticipantsToRun = true and allowsUserScriptExecution = false, combine that with allowedDirectoriesAndFiles to restrict file access, and add required third-party components to the participant allow list.

Migrate legacy interception code in older exam software

What to do: Replace legacy code such as CGEventTap and hidden window overlays with standard AAC framework APIs.

Why it is worth doing: Custom interception code easily conflicts with system updates and is expensive to maintain. AAC is implemented at the system level, providing better stability, compatibility, and simpler code.

How to start: Identify all custom keyboard interception, window covering, and process monitoring logic in the project. Gradually replace each piece with the corresponding AEAssessmentConfiguration property, then remove the low-level hacks that are no longer needed.

Comments

GitHub Issues · utterances