Guide · CompanionGuard · Published 14 November 2026 · Reviewed 14 November 2026 · By the Ingenious AI team
Parent Notification: What the notify_parent Flag Does and Does Not Do
The short answer
When a crisis signal class matches in a minor session, CompanionGuard's runtime records a parent-notification flag (the notify_parent action) in the sealed evidence. Read the design precisely: the runtime records the need; it does not send anything to any parent, because the kit stores no contact details — counts-only, identifier-free by design. The notification itself is the operator's process, on the operator's channel, and this guide is about building that process so the flag never lands in an unwatched queue.
What is the parent-notification flag?
The parent-notification flag is a recorded marker in the runtime's evidence chain, set when a crisis decision (and cap enforcements) occur in a minor session. It tells the operator 'this event needs your parent-notification process to run' and proves afterwards that the need was recognised at the time. The actual notification — to a parent, guardian or safeguarding contact — is performed by the operator through their own systems.
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.
Why the kit flags instead of notifying
The design looks like a limitation until you see the alternative. For CompanionGuard to notify a parent directly it would need to hold parent identities and contact routes for every minor user — a database of children's families attached to crisis records, which is precisely the kind of sensitive store the product's privacy architecture refuses to build. Referral metrics are counts only; evidence holds classes and hashes; there is no field anywhere for 'parent's email', and that absence is intentional.
So the runtime does the two things it can do with integrity: it detects the condition (crisis signal in a minor session) deterministically, and it records the flag in a tamper-evident chain with a timestamp. Everything after that — the operator's safeguarding judgement, contact, and care — belongs to the humans who actually know the child. The flag is a baton, and this guide is about the hand it passes to.
Designing the operator-side process
A flag is only as good as its queue. Design four properties before launch. Routing: flags surface somewhere a named human watches — a safeguarding inbox, an on-call rota — not the general support queue and never a dashboard nobody opens. Clock: define the review window honestly (crisis flags in minor sessions deserve the fastest clock your organisation can truly staff, including weekends if minors use the bot then). Content: the reviewer works from decision facts — signal class, timestamps, session reference — plus whatever your own platform lawfully holds for safeguarding; the evidence chain contributes the sealed 'what fired, when' that your case notes cite. Closure: each flag ends with a recorded operator-side outcome (contacted, escalated, no action with reason), kept in your safeguarding records, so the loop is auditable end to end.
Rehearse it: run a staging minor session, fire a crisis phrase, and time the flag's journey from runtime event to a human's eyes. The rehearsal always finds the broken step — an unmonitored alias, a rota gap — while the stakes are fictional. The escalation guide covers the sibling workflow for in-conversation handoffs.
What to tell parents and partners, precisely
Language discipline matters here because the flag invites overclaiming. Your protocol page and partner documents should say what the system does: the bot detects crisis signals in minor sessions by pattern, shows crisis resources immediately, and flags the event for the operator's safeguarding process, which includes parent/guardian notification through the operator's own channels where appropriate. What you must not say: 'parents are automatically notified by the platform' — no such automation exists in the kit, and a parent relying on that sentence has been misled by it.
Where your deployments involve schools or youth organisations, the 'operator's own channel' is usually theirs: agree explicitly whose safeguarding process the flag feeds, whose clock applies, and what the partner receives (decision facts, not conversation content). Write it into the partnership paperwork before the first minor session, not after the first flag.
The flag as evidence, afterwards
Months later, the flag's second life is evidentiary. If a safeguarding decision is ever reviewed — by a partner, a parent or a regulator — the chain shows the flag was recorded at the time of the decision, in sequence, unedited: chain verification proves the record's integrity, and your safeguarding log shows what your team did with it. The two records together answer the only questions that matter: did the system notice, and did the humans act?
That pairing is the whole philosophy of the product in miniature — machines that notice deterministically and record honestly, humans who judge and act accountably. Keep the boundary bright in both directions: never ask the flag to be a judgement, and never let a human process claim the machine 'handled it'.
Five actions so a flag never lands nowhere
- Name the queue and the humans: parent-notification flags must route to a watched safeguarding channel with a rota, today, by name.
- Set and publish internally a review clock for minor-crisis flags that your staffing can actually meet, weekends included if minors are active then.
- Rehearse end-to-end in staging: fire a crisis phrase in a minor session and time the flag from runtime event to human eyes; fix what the rehearsal exposes.
- Write protocol-page and partner language precisely — the kit flags for the operator's process; it does not itself notify any parent.
- Close every flag with a recorded outcome in your safeguarding log, so machine record and human record together tell the complete story.
Worked example: one flag, forty minutes, a complete record
A fictional after-school companion, Clubhouse, receives a runtime flag at 19:42 on a Tuesday: self_harm_ideation primary in a minor session, show_crisis_resources returned to the user in the same decision. The flag lands in the safeguarding queue; the rota owner reviews at 20:05, sees the decision facts (class, timestamp, session reference), and follows Clubhouse's process: the account's registered guardian contact — held in Clubhouse's own platform, not in CompanionGuard — is reached through the school's safeguarding channel by 20:22.
The case note cites the evidence entry, whose hash verifies in the chain weeks later when the school reviews the incident. The review's conclusion is the design working as documented: the machine noticed in the moment and proved it later; the humans judged and acted within their stated clock. Every figure and name here is invented; the flag, its scope and its limits are the product's own.
Frequently asked questions
Does CompanionGuard notify parents directly?
No. The runtime records a parent-notification flag in the evidence chain when a crisis signal fires in a minor session (and on cap enforcements). The notification itself runs through the operator's own channels, because the kit stores no parent contact details by design.
What information does the flag carry?
Decision facts: the signal class, the action, the timestamp and the session reference — sealed in the hash chain. It does not carry the message text (only its one-way hash) or any identity.
When exactly is the flag set?
When a crisis signal class matches in a session flagged as a minor session, alongside the show_crisis_resources decision; enforce_break decisions in minor sessions also record it.
What should our safeguarding process include?
A watched queue with named owners, a review clock you can truly staff, a contact route held in your own systems, and a recorded outcome per flag. Rehearse the full path in staging before launch.
How should we describe this to parents?
Precisely: the bot shows crisis resources immediately and flags the event for your safeguarding process, which notifies parents or guardians through your own channels where appropriate. Never claim the platform auto-notifies — it does not.
Keep going
Related guides: Minor Safety for AI Companions: Break Reminders, Caps and Parent Flags · Human Handoff: Teaching a Companion Bot to Escalate to a Real Person · Session and Daily Caps: How the Runtime Enforces Breaks for Minors
Put it to work: Create the free kit · Eval harness · Scenario tests · Crisis runtime · Disclosure packs · Pricing · All CompanionGuard guides