Age Assurance & Minors
The age signal the new laws build is delivered to an app at launch — and an agent calling your API arrives with nothing attached.
California's Digital Age Assurance Act, operative 1 January 2027, makes the operating system hand each app an age bracket; New York's chatbot law, signed 28 October 2026 and applying from 1 January 2027, requires more than one age-assurance method and triggers on what you actually know. Both were drafted for a person holding a device. Neither reaches a server-to-server call made by someone's agent on their behalf, which means age assurance has stopped being a signup-time check and become a property you must carry through every delegation — or deliberately refuse to serve without.
Step 1Know which of the two regimes you are in, because they ask for opposite things.
By late 2026 the US has settled into two distinct models, and an agent product can easily be caught by both.
- Platform-signal laws. California's AB 1043, signed in October 2025 and operative 1 January 2027, puts the work on the operating system: at account setup the OS collects a birth date or age and exposes a real-time API that returns one of four brackets — under 13, 13 to under 16, 16 to under 18, and 18 or older. Developers must request that signal when an app is downloaded and launched, and there is no carve-out for business applications. Devices set up before 2027 give OS providers until 1 July 2027 to present the interface. The App Store Accountability Act model — enacted in Utah, Texas and Louisiana in 2025, with the Texas law effective in 2026 — pushes the same idea further, putting parental consent in the app store rather than only the age bracket.
- Conduct laws for conversational AI. California's SB 243 companion-chatbot rules took effect 1 January 2026. New York's S9051-B was signed on 28 October 2026 and applies from 1 January 2027: it prohibits "unsafe AI companion features" for minors, and the features it names are behavioural rather than topical — implying the system is a real human or a fictional human character, flattery and sycophancy, and endorsement of suicide, self-harm or disordered eating, alongside sexually explicit conduct and features that encourage secrecy or isolation.
The difference matters operationally. A platform-signal law tells you what you will be given. A conduct law tells you what you must not do once you know who you are talking to — and in New York the duty attaches when the operator has actual knowledge that the user is a minor. The exemptions are the clearest statement of where the line sits: operators offering only customer service, technical support or internal tools are outside it. The question to ask of your own product is therefore not "is this a chatbot" but "can a minor hold an open-ended conversation with it".
Step 2The assurance requirement is a shape, not a vendor choice.
New York's interim standard — in force until the attorney general's rules land — is unusually specific about structure, and it is the most useful template available because it says what a single method cannot buy you. Operators must use a reasonable age-assurance method that resists circumvention and minimises data retention; they must offer more than one method, including at least one that does not rely solely on government ID; and self-declaration is acceptable only when the user self-declares as a minor.
That last clause is the design constraint, and most teams get it backwards. Age claims are a one-way ratchet:
- "I am 14" is dispositive. You may act on it immediately, with no verification, and you now have actual knowledge.
- "I am 19" is worth nothing. An unverified upward claim neither establishes adulthood nor protects you.
- Therefore the only self-service flow that reduces your duty is one that raises assurance — a bracket from the platform, a verified credential, a payment instrument, an ID check — and every other signal can only increase it.
"Actual knowledge" is not a safe harbour you can engineer around by declining to look. A support transcript where the user says they are in ninth grade is knowledge; so is a parental-control flag your app already receives. Building a pipeline that strips those signals before they reach the policy layer is the rare compliance posture that is both expensive and worse than doing nothing, because the signal still exists in your logs.
Step 3Where the signal dies: the agent is not an app launch.
AB 1043's signal is requested by a developer from the OS or app store at download and launch. That is a client-side event in a session with a human in it. Now trace the three paths an agent takes to the same product and watch the bracket disappear:
# Path 1 — human in your app. The signal exists. device OS --bracket:13-15--> your app --> your API # bracket available, attach it # Path 2 — the user's personal agent calls you. No launch, no OS, no bracket. user -> their agent --OAuth token--> your API # token says WHO. nothing says HOW OLD. # Path 3 — your own agent runs later, on a schedule. The user is not present. scheduler -> your agent --service creds--> your API # acting FOR a user who is offline
Paths 2 and 3 are the whole problem. The delegation token in path 2 carries identity and scope, and standard OAuth scopes have no notion of an age bracket — so an age gate enforced in your app's UI is bypassed, legitimately and without any evasion, by the user's own assistant. Path 3 is worse: the duty applies to an interaction that is happening while the human is asleep, and scheduled and triggered agents are exactly the surface where nobody thought to ask.
The fix is to treat the bracket as a claim in the delegation rather than a fact about the session, and to decide what happens when it is missing:
# The delegation token, extended. Claims your authz layer must see. { "sub": "user_8821", # who "act": { "sub": "agent_mail_v3" }, # who is acting (RFC 8693 actor claim) "scope": "threads.read compose.draft", "age_bracket": "16-17", # NOT a birth date. The bracket is the whole answer. "age_method": "os-signal", # os-signal | verified-id | self-declared-minor | none "age_asserted_at": "2026-11-20T08:04Z" } # The rule that does the work, enforced at the tool boundary: # age_bracket absent -> treat as UNKNOWN, not as adult. # UNKNOWN + age-gated tool -> refuse, and say which claim is missing.
Defaulting an absent bracket to "adult" is the single decision that converts a drafting gap into a finding. Default it to unknown and gate on it, the same way you would gate on any other missing authorisation — see fail-closed and fail-open for why this particular default is not a judgement call, and delegated access and consent records for where the assertion is stored.
Step 4Decide per tool, not per product, and write the age-gated list down.
A product-level age gate is both too coarse and too easy to route around. The enforceable unit is the tool, because that is where the irreversible thing happens and where you already have a policy hook. Classify the catalogue once:
- Open. Read-only, no persona, no open-ended generation. Search, status, pricing. No bracket needed.
- Bracket-sensitive. Anything whose behaviour is what the conduct laws name — open-ended conversation, persona or companion surfaces, memory that personalises over time. Requires a known bracket; behaviour changes by bracket rather than being refused outright.
- Adults only. Payments, contracts, age-restricted goods, anything your terms already restrict. Requires a bracket of 18-or-older established by a method stronger than self-declaration.
- Never for minors, whatever the bracket says. The New York list is the floor, and it is a list of behaviours. A sycophantic reply is not a feature flag you can condition on an age claim you half-trust.
The third bucket is where agent traffic hurts most, because the sanctioned pattern for agent commerce assumes an adult principal that nobody checked. If your product lets an agent spend money, the age question lands in the same place as the authorisation question; see agent payments and shopping and checkout agents. For products whose users are minors by design, tutoring and learning agents is the playbook that assumes it rather than discovering it.
Step 5Third-party agents: you cannot verify their user's age, so price the refusal.
When someone else's agent calls you on behalf of their user, you are being asked to accept an age assertion from a party with no incentive to get it right and no mechanism to prove it. The honest options are three, and they are the same three that show up in every third-party agent access policy:
- Refuse the age-gated subset. Keep the read paths open, decline the bracket-sensitive and adults-only tools to unsanctioned agents. Cheapest, and defensible.
- Require a signed assertion. Accept a bracket only inside a request you can attribute to a named, contracted agent operator whose assurance method you have reviewed. This is a contract plus signed agent requests, not a header.
- Do your own check in the loop. Interrupt the agent's flow and put the human back in front of an assurance step you control. It breaks the automation, which is the point: the handoff is the assurance.
What does not work is trusting a self-reported bracket from an unauthenticated caller, and then relying on the "good faith" language some of these statutes extend to signal recipients. That protection is written for a developer who requested a platform signal and got an inaccurate one — not for one who accepted a number from an arbitrary HTTP client.
Step 6Prove the check without keeping the evidence.
Age assurance creates the worst kind of audit requirement: you must be able to show you checked, using a record you are explicitly told to minimise. New York's interim standard pairs circumvention-resistance with data minimisation in the same sentence, and the resolution is to log the decision rather than the input.
- Store the bracket and the method, never the birth date or the document. "16-17, os-signal, 2026-11-20" is a complete audit record. A scan of an ID is a breach waiting for a quarter to end.
- Log refusals as first-class events. The record that defends you is the one showing an age-gated tool declined on a missing bracket. Route it with your refusal monitoring, and alert on the rate: a sudden drop usually means a client started defaulting the claim.
- Expire the assertion. A bracket asserted eleven months ago is not a current fact about a 17-year-old. Give it a lifetime shorter than the distance to the next bracket boundary, which for the 16-to-18 band means re-asserting at least annually.
- Carry it into memory and retrieval. A personalisation store that learned who the user was while they were 17 keeps acting on it afterwards; erasure against agent memory is the mechanism, and the bracket change is a trigger for it.
Then register the whole thing where a regulator will look for it: an entry in your agent inventory naming each surface a minor can reach, the assurance method behind it, and who owns the behaviour list. Related: impact assessments for the pre-launch version, and the regulatory landscape for how this sits alongside the rest.
Do this today: find the line of code where your authorisation layer reads the user's age, and check what it does when the field is absent. In most agent products there is no such line, which means the answer is "treats everyone as an adult". Add an UNKNOWN bracket, make it the default, and make one tool refuse on it — the most behaviourally risky one you have. That single refusal path is worth more than a vendor contract, because it is the thing you can show.