How we answer HR policy questions on autopilot
Every week the HR inbox fills with the same few questions. How many days of PTO roll over? What does the remote-work policy really let me do? What's the spending cap for a conference? When does parental leave start building up? None of it is a secret. It's all written down in a Notion policy library that anyone in the company can open. Still, someone has to find the page, quote it correctly and write the reply, and that pulls them away from the work only a person can do: the exception request, the accommodation, the hard conversation.
Now an agent on Machine checks that inbox every 15 minutes. If the answer is in the library, it writes it up. If not, it passes the question on. It does not send email on its own, and it never rules on a question the library hasn't already settled. Either it drafts or it escalates, and a person handles what comes next.
The problem
These questions arrive in bulk and barely vary. Most already have an answer, often in exact wording, somewhere in the library. The inbox can't tell, though. "How many sick days have I got?" sits in the same line as "Can we talk about a medical accommodation?", and someone has to open every thread just to learn which kind it is before writing a word.
The common fixes fall short. An FAQ page only helps people who remember it exists. An auto-reply with a link to a shared doc can't read the actual question or point to the paragraph that answers it. Sending everything to a person means the simple, written-down questions fight for the same time as the ones that truly need HR's judgment: legal matters, personal circumstances, pay. That's the wrong way round.
What we built
Every 15 minutes a schedule starts a new session on Machine. The agent can read the HR Gmail inbox and the Notion policy library without changing them, and it can post into Slack. It picks up new questions and sorts each one. When the library covers it, the agent finds the precise policy section and writes a reply based on it, saved as a Gmail draft that is never sent automatically. When a question is unclear, legal, personal or about pay, the agent doesn't try to answer. It posts it to HR's Slack channel along with the reason it needs a person.
How it works
Start a clean run every 15 minutes
A cron trigger goes off every quarter hour. Each time, it opens a brand new session, a fresh cloud computer (sandbox) that remembers nothing from the run before. To keep track of what it has already done, the agent uses Gmail labels rather than its own memory. That way no thread is handled twice and none slips through the gap between runs.
Teach it how to sort and how to answer
The agent carries a skill that explains how to separate a question the policy covers from one that needs HR. It defines "answerable from policy", sets a firm line for escalation (unclear, legal, personal or pay-related), and shows how to write a reply that quotes the source, or stays very close to it, rather than loosely retelling it.
Hook up the inbox, the library and the hand-off channel
The agent uses scoped connectors, connections that Machine brokers on the server so the model never sees a raw token. Through them it handles:
- Questions in Gmail: it scans the HR inbox for threads with no label yet, and the only thing it writes there is a draft. It never sends.
- Policies in Notion: it reads the policy library without editing it, looking for the exact page that answers each question.
- Hand-offs in Slack: anything the policy doesn't cover goes to the HR channel, with the question and why it needs a person.
Set firm limits
The agent answers what the library actually says and nothing else. It won't fill gaps, stretch a rule or guess at policy that isn't written, and it never grants an exception. Sending is off limits too: each answer waits in Gmail as a draft for HR to check and send. Legal, personal and pay questions go to Slack without an attempted reply, with no exceptions.
Draft, hand off, label
Once that's set up, the inbox gets worked every 15 minutes. Questions the policy covers end up with a drafted reply in Gmail that cites its source. Everything else appears in HR's Slack channel with the question and the reason it was passed on. The agent labels each thread so the next run skips it. HR reads the drafts, sends the good ones, and deals with the hand-offs in person.
The pattern
Every 15 minutes a cron opens a fresh session that can read Gmail and Notion and post to Slack. The rules for sorting and answering live in a skill. The agent either drafts from written policy or hands the question to HR. It never sends, and it never decides a policy point the library hasn't.
Guardrails
This agent reads employees' messages and the company's official policy, so its reach is limited and a person holds every output before it goes anywhere:
- Answer from documented policy only. It never makes up, reads between the lines of, or widens a policy past what the Notion library says. If the library isn't clear on a question, it escalates rather than guessing.
- Drafts only, never sends. Everything it writes is saved as a Gmail draft. HR checks it and hits send; the agent has no ability to send.
- No exceptions, ever. Granting, waiving or bending a policy is not something the agent can do. That decision is HR's.
- Hard escalation triggers. Questions that are unclear, legal, about someone's personal situation or about pay go straight to a person in Slack, with no attempt to answer.
- Read-only into the policy library. Notion pages are never edited by the agent.
- Scoped secrets. Gmail and Notion are reached through brokered connectors, limited to the agents you grant them to.
The outcome
Simple policy questions no longer wait behind everything else. Within 15 minutes they have a draft ready to send that quotes the exact policy behind the answer. The questions that need HR's judgment appear in Slack straight away, and nothing in between is guesswork. The agent reads and drafts; HR decides and sends.
More use cases
How we answer GDPR data-subject requests before the deadline
Our Machine agent checks each GDPR access or deletion request, finds the person's data across our product database, builds the report well within the SLA and hands it to legal before anything is sent.
How we keep our docs matching what the code does
Once a day a Machine agent reads every commit merged since its last pass, finds the doc pages those changes made wrong, rewrites them and sends you one pull request to review.
How we test every pull request without lifting a finger
Our Machine QA agent works with GitHub and our test environment. For each pull request it checks out the branch, runs the tests, tries the change for real, and posts what it found.
Put your first agentto work today.
- SSO
- RBAC
- Governed agents
- Full audit trail