Your people team became the company's help desk: the same handbook questions hundreds of times, onboarding scattered across five systems, letters requested and forgotten. An AI-native people-ops function puts the whole desk on a workforce, while every letter and every commitment still waits for HR.
Installed in minutes, not months. Governed and audited from the first run.
Every stage of the desk is worked by the right kind of worker (an unattended play, a team that faces your employees, a room of specialists), all reading and writing one shared record, with HR at the gates that matter.
You don't wire this together or choose an architecture. You describe the outcome; the workforce brings the right kind of worker to each part of the day, and they all work from one shared record, under one set of rules.
The repeatable plays (answering a handbook question, running an onboarding checklist) go start to finish on their own, unattended, day or night. No one keeps the checklist alive in their head.
Employee questions are met in the moment by a team that answers from your handbook, cites the section it used, and escalates the second the docs don't cover the question.
When a case needs policy, comp and the employee record weighed together, a room of specialists works it as one, each owning its part, and the decision still holds for a person.
You don't operate a portal. You talk to one coworker that runs the people desk, remembers your standing instructions, and surfaces only what needs you.
Every worker reads and writes the same people, policies and checklists, and every one obeys the same gates, budgets, audit and a strict PII policy. No worker is ever off the leash.
There's no integration project and no architecture to pick. You delegate the outcome, the workforce assembles the right workers, and every one of them lands under the same gates, PII policy and audit.
Not a chatbot bolted onto HR: a workforce that owns the repeatable questions and checklists, and structurally cannot touch the decisions that are yours. The week shifts like this (a worked scenario, not a benchmark):
Employee questions are answered from your own handbook and policy docs, retrieved and cited. When the docs don't cover it, the question escalates to a person, because an improvised leave-policy answer is a liability, so it never happens.
Accounts, forms, welcome docs and checklists across every system a new hire or leaver touches, driven to done, with nothing dropped between tools and nothing living in one coordinator's head.
Employment and verification letters are drafted the hour they're asked for, and every one holds at the approval gate. One single-use grant releases exactly one letter, then the next one asks again.
The decisions that carry the most weight are structurally human: the writes that would enact them always stop for a person. The workforce prepares context and keeps records straight, but the judgment stays with your team.
June isn't a portal you administer, it's the coworker you delegate the desk to. The day's questions arrive answered and cited, the escalations arrive exactly as asked, and the one document that needs you is already holding with its draft attached, each approval releasing exactly one thing.
Every message, tool call and approval in this exchange lands in the audit trail. How the gates work →
A scenario: a growing company, a start date, and the usual stream of policy questions. These are real screens, not mockups.
Every policy answer is retrieved from your handbook and cites what it used; what the docs don't answer escalates to a person instead of being improvised. Inbound employee messages are untrusted input, so a prompt-injection shield screens them before they reach a model. The control plane →
Letters and every employee-facing send hold for review, enforced at the tool call, at runtime, so an unapproved send is a no-op. Each approval is single-use: one grant, one letter, 24-hour expiry, then the next one asks again. Comp, offers, performance and terminations are structurally human. How approvals work →
Employee data sits under an explicit PII policy with redaction, table access scoped by role, and every read and write in the audit trail, pinned to the config version that ran. The most sensitive data you hold, handled in a way you can defend.
