How we find candidates for our open roles
Hiring well means more than reading whatever applications show up. For plenty of roles, the people you most want are happily employed and not applying to anything. Reaching them means digging through LinkedIn yourself, checking your applicant tracking system (ATS) so you don't approach someone who's already in your pipeline, and writing a note that mentions their real experience rather than a copy-paste template. Doing that properly eats hours for each role. When the week gets busy, it doesn't happen, and the seat stays empty for longer.
So an agent on Machine handles the searching and the first draft, every day. For each open role it finds people on LinkedIn who fit, checks Greenhouse so it never brings back anyone already in the pipeline, and writes a personal outreach email that draws on each person's actual background. Its job is to find and draft. The recruiter reads every draft, and no email goes out and nobody lands in the ATS unless they do it. This is how we build our own outbound pipeline.
The problem
Outbound hiring is research first and writing second, and neither part keeps up when done by hand. Hunting LinkedIn for people who truly meet a role's bar takes time, and doing it properly for several open roles every day is more than one recruiter can keep up. On top of that comes the duplicate check. Did this person apply already? Did someone reach out before? Were they turned down in an earlier round? Skip it, and a candidate gets the same cold email twice, which looks careless at the very least.
The common shortcuts only add to the mess. A typical sourcing tool spits out a list of profiles that knows nothing about your pipeline, so recruiters keep finding people who are already in Greenhouse. A template email goes to the whole list with only the name changed, and anyone who gets a lot of these can spot one at a glance. Moving faster won't solve either problem. Linking up the systems that already know the answers will.
What we built
A daily timer on Machine wakes an agent. It opens a session, a fresh cloud computer (a sandbox) used only for that run, focused on a single open role. The agent searches LinkedIn for people who fit the role's profile and checks that role's Greenhouse pipeline so it never suggests anyone already there. For each new match it writes a personal outreach email that mentions the person's real background instead of a template. Every draft goes to the recruiter's inbox to be reviewed. The agent never emails a candidate and never makes changes in Greenhouse.
How it works
Start a fresh run every day
A cron trigger (a timer) wakes the agent once a day. Each wake-up creates a brand-new session in its own sandbox, focused on one open role. That way each day's batch is found and checked against the pipeline as it stands today, with nothing left over from yesterday.
Describe who you're looking for
What counts as a good fit for this role, such as title, seniority, skills and any other useful search criteria, is kept in skills and memory: the playbook the agent keeps and improves. Next to it sit the outreach angles that get a message opened rather than ignored. When the bar for the role moves or a certain kind of message earns more replies, we note it down, and tomorrow's batch follows suit.
Hook up Greenhouse, LinkedIn and email
The agent uses connectors: scoped connections to your tools, with keys held on the server so the model never sees a raw token. With them it can:
- Search LinkedIn: for people who match the role's profile.
- Look in Greenhouse: at the role's pipeline, so anyone who has applied, been contacted or been turned down is skipped instead of suggested again.
- Write email drafts: a tailored message for each new candidate that draws on their real background, waiting for the recruiter to send.
Stop at the draft
The agent's work ends once the draft is written. It never sends outreach on its own, and it never adds, moves or tags anyone in Greenhouse. Finding and drafting is the whole job. Credentials are stored encrypted in the Secrets Manager and only handed to the agents you grant them to.
Give the recruiter a ready batch
The upshot: every morning brings a small set of new candidates for the open role. Each comes with a draft email that mentions their real background and a short note on why they fit. The recruiter reads them, tweaks what they want and sends the emails personally. If they decide to add someone to Greenhouse, they do that too. The drafts are the only thing the agent produces.
The pattern
A daily cron opens a fresh session for a single open role, with connectors into LinkedIn for finding people and Greenhouse for skipping duplicates. The role profile and outreach angles live in skills and memory. The agent writes email drafts and stops there. The recruiter reviews, sends and owns the ATS.
Guardrails
This agent can look up real people and could reach out to them, so the line between drafting and sending is the control that counts:
- Isolation. Each run happens in its own sandbox, focused on one open role. The drafted emails are the only thing that leaves it.
- Scoped secrets. The Greenhouse and LinkedIn credentials are stored encrypted in the Secrets Manager, delivered into the sandbox when the run starts, and only handed to the agents you grant them to.
- Human approval gate. The agent never sends outreach and never adds a candidate to Greenhouse. Each draft waits for the recruiter to review, change and send, and keeping the ATS up to date is their call.
- Dedupe before draft. Before writing a word, the agent checks the role's Greenhouse pipeline, so nobody who has applied, been contacted or been turned down gets approached twice.
- Everything is code. The role profile, the outreach angles and the permissions for each system are files in your repo. They're versioned, and you change them through a reviewed change request, not a dashboard toggle.
The outcome
Sourcing for an open role now begins with a batch that's already been searched, checked against the pipeline and drafted with a genuine nod to each person's background. The recruiter starts the day reviewing instead of digging, and every email sent and every change in the ATS is still theirs to make.
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