How we keep interview loops on schedule
A candidate passes the screen, and suddenly booking the next round is a little project of its own. You check the interview plan to see who sits on the panel, hunt for a slot when all of them are genuinely free, offer it to the candidate, and get invites onto every calendar before that slot disappears. No single step is difficult. Multiply it by a few interviewers and a few candidates, though, and it turns into a slog. Each day it waits is a day the loop stands still.
So an agent on Machine handles that coordination daily. For each candidate flagged as ready to schedule in Greenhouse, it reads the interview plan, looks up the panel's free time in Google Calendar, and drafts both a time proposal for the candidate and an invite for each interviewer. It sends nothing and has no say in hiring. A coordinator checks every proposal and invite before anything leaves. That's how our own interview loops keep moving.
The problem
Booking an interview loop means joining up two systems that never talk. The plan sits in Greenhouse: who's on the panel, how many rounds there are and how long each takes. Whether those people are free sits in their calendars. Checking both by hand for every candidate who passes a screen is exactly the sort of admin that falls behind as soon as you have more than one open role.
The usual shortcuts break down. A shared booking link is only as good as each interviewer's habit of keeping it up to date, and it can't tell you who the panel should be for this particular candidate. A coordinator flipping between a stack of calendar tabs and Greenhouse can manage, but not beyond a handful of loops. And a missed invite makes you look disorganised to a candidate who is probably talking to other companies too.
What we built
Once a day a schedule wakes an agent on Machine. It opens a fresh session, a cloud sandbox, and reads every candidate in Greenhouse who is flagged as ready to schedule. For each one it opens the interview plan to find the panel, checks every panelist's Google Calendar for free time, and drafts a time proposal for the candidate plus one calendar invite per interviewer. All of those drafts go to the coordinator. The agent sends nothing and makes no decisions about the candidate.
How it works
Start once a day on a schedule
A cron trigger starts the agent daily. Every run gets a brand new session, a fresh cloud computer (sandbox) just for that run, so both the list of candidates ready to book and the panel's true free time are worked out again from how things stand today. Nothing is carried over from yesterday.
Teach it how we schedule
The agent brings our habits along as skills and memory: how to read an interview plan, how many time options to offer, how far ahead to search for free slots, and what a good proposal to a candidate sounds like. If we change how our loops are set up, we update that file, and tomorrow's proposals follow the new rules.
Hook up Greenhouse, Google Calendar and email
The agent uses scoped connectors, connections that Machine brokers on the server so the model never sees a raw token. Through them it can:
- Check Greenhouse: see which candidates are flagged ready to schedule, and open each one's interview plan for the panel, the round and the length.
- Check Google Calendar: look up when each interviewer on the plan is free, so any time it suggests is one the whole panel can make.
- Write drafts in email: a time proposal for the candidate and one calendar invite per interviewer, held for the coordinator.
Stop at the draft
Drafting is where the agent's work ends. It doesn't email candidates, it doesn't send calendar invites, and it never makes or hints at a hiring decision: no rejections, no moving someone to the next stage, no offers. Credentials are stored encrypted in the Secrets Manager and only handed to the agents you grant them to.
Give the coordinator a ready batch
From then on, every morning brings a batch of candidates ready to book, already matched to when interviewers are actually free: a suggested time for the candidate and an invite drafted for each panelist. The coordinator looks it over, confirms the time and sends, or tweaks things first. Nothing reaches a candidate or lands on an interviewer's calendar unless they do.
The pattern
Every day a cron opens a fresh session with connectors to Greenhouse for the interview plan and Google Calendar for the panel's free time. Our scheduling habits live in skills and memory. The agent drafts the candidate proposal and the invites, then stops. The coordinator confirms and sends.
Guardrails
The agent shapes a candidate's next step in hiring, so the line between "suggested" and "confirmed" is the control that counts:
- Isolation. Each run happens inside its own sealed sandbox. The drafted proposal and invites are the only things that come back out.
- Scoped secrets. Greenhouse and Google Calendar credentials are stored encrypted in the Secrets Manager and only handed to the agents you grant them to.
- Human approval gate. The agent sends neither the candidate proposal nor any calendar invite. Each draft waits for the coordinator to check, tweak and send.
- No hiring decisions, ever. Rejecting a candidate, moving them forward and making an offer are all beyond its reach. It books the next conversation; it never decides whether that conversation should take place.
- Everything is code. Scheduling habits and each system's permissions live as files in the repo. They're versioned and only change through a reviewed change request, not a dashboard toggle.
The outcome
Booking a loop now begins with a proposal and a set of invites already drafted from the panel's real calendars, rather than a coordinator juggling five tabs in search of one time that suits everyone. Their morning starts with a quick review, not a hunt. Every send, and every hiring decision, still belongs to a person.
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