Guide · CompanionGuard · Published 14 November 2026 · Reviewed 14 November 2026 · By the Ingenious AI team
Configuring Minor Mode: Asserting the Flag, Setting the Layers, Verifying the Behaviour
The short answer
Minor mode is switched on per bot in the kit and asserted per session in the runtime — and both depend on one upstream decision only you can make: how your product knows a user is a minor. Configure in four steps: define your age-knowledge basis and document it; enable minor mode so break reminders fire in the snippet; assert the flag at runtime session start for known-minor sessions with caps configured; then verify end-to-end that reminders, enforce_break and parent flags occur where they should.
What is minor mode configuration?
Minor mode configuration is the set of operator decisions and settings that make CompanionGuard's minor protections real for a given bot: the age-knowledge rule (who counts as a known minor), the kit-level switch (break reminders in the snippet), and the runtime-level assertions (session flags and caps) — plus the verification that proves each layer fires.
Create the free safety kit Next guide All guides
CompanionGuard is built by Ingenious AI. A compliance toolkit — not legal advice and not a clinical service. If you are in crisis right now: US — call or text 988; UK & Ireland — Samaritans 116 123.
Step one: the age-knowledge decision is yours
Every minor protection in the product is keyed to known minors — the packs' own word. The kit cannot know your users' ages; your product's design decides what knowledge means: account birthdates, school-issued accounts, age-gated registration, a guardian-created profile, self-declaration at signup. Each basis has a different reliability, and the honest configuration records which basis you use and its known weakness (self-declaration is weak; provisioned accounts are strong).
Two rules protect the decision's integrity. Never infer the flag per-message from conversation vibes — a user 'sounding young' is not knowledge, and flagging on vibes both over-applies restrictions and under-documents your basis. And never let the flag be user-editable in-session: a control that lets a minor declare themselves adult mid-chat converts your safeguard into a suggestion. The flag is account-level truth, asserted by your systems.
Step two: the kit-level switch and what it turns on
Enabling minor mode in the bot's kit activates the free layer: the disclosure snippet offers break reminders at least every 3 hours for known minors, with the state pack's minor wording in the banner (California's explicit 3-hour promise; Colorado's session check-in). This is the layer with no runtime dependency — it works for free-tier bots and in surfaces where the runtime is not integrated, which is why it is configured at kit level rather than per session.
Verify it like a user: with a known-minor test account, confirm the banner's minor line is the right pack's wording and the reminder arrives on cadence in a long session. A configuration that has never been observed firing is a hope, not a setting — and this layer is observable in minutes, so observe it.
Step three: runtime assertions and caps
On Pro and Team, each session start asserts the minor flag for known-minor sessions, and the operator's caps (session minutes, daily minutes) ride with the configuration the runtime enforces. The assertion must come from the same account-level truth as step one — the backend reads the account's minor status and asserts it; nothing in the chat path should be able to set or clear it. Caps are set once, deliberately, with the reasoning recorded (see the caps guide for choosing values).
Also configure the flag's destination: parent-notification flags from minor sessions must route into your safeguarding queue the moment the runtime records them. A runtime flag with no downstream routing configured is the classic half-finished minor mode — detection without consequence. The notification guide covers building that route.
Step four: verify the whole chain, then re-verify on change
The end-to-end verification is a scripted minor session in staging: start flagged, confirm disclosure flow, send a crisis phrase and observe show_crisis_resources plus a parent flag in your queue, run the session to its cap and observe enforce_break, then export and confirm each event is sealed in order. That single script exercises every layer minor mode touches — snippet assumptions, runtime assertions, caps, flags, evidence.
Re-run it whenever any input changes: your age-knowledge basis, the caps, the pack, the runtime integration, or the account system that feeds the flag. Minor mode is a chain of configurations owned by different parts of your stack, and chains fail at their joints — usually silently, which is why the verification is a rehearsal and not a code review. Keep the script; it is the cheapest safeguarding asset you own.
Five actions to configure minor mode completely
- Write down your age-knowledge basis (provisioned accounts, declared birthdate, guardian-created profile) and its weakness — and never let the flag be set from in-chat vibes or edited mid-session.
- Enable minor mode in the kit and observe, as a test minor, the banner's minor wording and a break reminder arriving on the 3-hour cadence or better.
- Assert the flag at runtime session start from account-level truth, with session and daily caps configured and their reasoning recorded.
- Route parent-notification flags into a watched safeguarding queue before the first real minor session.
- Script the full staging verification — disclosure, crisis phrase, flag, cap, export — and re-run it after any change to accounts, caps, packs or integration.
Worked example: a reading app configures minor mode in four steps
A fictional reading companion, Chapter, serves school accounts (provisioned by teachers) and public signups (self-declared birthdate). Step one is documented honestly: provisioned accounts are strong knowledge; self-declared signups are treated as minor when the declared age says so, and the team accepts the weakness in writing rather than pretending it away. Step two: minor mode on; a teacher test account confirms the banner wording and a reminder inside a long session.
Step three: the backend asserts the flag for both account types from the account record, caps set at 60 minutes per session and 3 hours daily for minors, flags routed to the safeguarding inbox Chapter's small team actually reads. Step four: the staging script passes end-to-end — including the discovery that public-signup sessions were initially started unflagged due to a field-name mismatch, found by the rehearsal and fixed before launch. The story is invented; the configuration layers and their order are the product's.
Frequently asked questions
How does CompanionGuard know a user is a minor?
It does not — the operator's product knows, on whatever basis it defines (provisioned accounts, declared birthdates, guardian-created profiles), and asserts the minor flag. The packs' duties attach to known minors; the kit enforces against the operator's assertion.
What does enabling minor mode in the kit do?
It activates the free layer: break reminders at least every 3 hours for known minors in the disclosure snippet, with the state pack's minor wording. On Pro and Team, sessions flagged as minor also get runtime caps and parent-notification flags.
Can the minor flag be set from conversation content?
It should not be. The flag is account-level truth asserted by your backend at session start — never inferred per-message and never editable by the user mid-session.
What caps should I configure?
Your own defensible values for your youngest audience — the product presents no cap as a statutory number. Record the reasoning, keep the session cap inside the 3-hour reminder cadence, and review enforce_break distributions monthly.
How do I verify minor mode works?
A scripted staging session: flagged start, disclosure flow, a crisis phrase (expect resources plus a flag in your queue), run to the cap (expect enforce_break), then export and confirm every event sealed in order.
Keep going
Related guides: Minor Safety for AI Companions: Break Reminders, Caps and Parent Flags · Session and Daily Caps: How the Runtime Enforces Breaks for Minors · Parent Notification: What the notify_parent Flag Does and Does Not Do
Put it to work: Create the free kit · Eval harness · Scenario tests · Crisis runtime · Disclosure packs · Pricing · All CompanionGuard guides