# How we onboard new hires

A new-hire record triggers an agent to provision accounts, add the person to the right groups and channels, and file a first-week checklist, with account creation and group membership held for approval.

Canonical page: https://openchatly.com/use-cases/employee-onboarding

Onboarding a new hire spans several systems on day one. There's a Google
Workspace account to create, groups and aliases to add them to, Slack channels to
invite them into, and a first-week checklist someone has to remember to file.
Each step is small, but they live in different tools, and the person doing the
setup is rarely the person who owns every system. Steps get missed, and a new
hire waits on access they should have had on their first morning.

We handle this by tying the setup to the event that starts it: a new record in
our HR system. This writes up how we run that on Kortix — the connections, the
steps, and the guardrails — so you can set up the same flow for your own team.

- **Team:** Kortix
- **Trigger:** A new-hire record
- **Connected systems:** Google Workspace · Slack · Linear
- **Mode:** Trigger-driven · Approval-gated

## The problem

The common approaches each leave gaps. A written runbook depends on a person
following every step by hand, and the steps drift as the tools change. A no-code
automation handles the happy path it was built for but can't reason about which
groups a given role needs. And handing each system to a different owner means the
new hire's access lands piecemeal over their first few days.

We wanted the accounts, memberships, and checklist a new hire needs to be
prepared the moment their record exists, with the irreversible steps held for a
person to confirm.

## What we built

On Kortix, a new-hire record triggers an agent. Each new hire runs in its own
isolated session — a cloud sandbox — with scoped access to what onboarding needs:
Google Workspace, Slack, and Linear. The agent reads the role, prepares the
account, the group and channel memberships, and a first-week onboarding
checklist, and files them. Account creation and group membership stop at an
approval gate before anything is provisioned.

## How it works

### Copy the setup prompt into a new session

Open your Kortix workspace, start a new session, paste this prompt and send it.
The agent writes the agent file, the onboarding checklist skill and the hourly
trigger, and opens a change request for you to review. Prefer clicks? Choose **Use this
template** instead.

**Setup prompt**

```
Set up an employee onboarding agent in this workspace.

1. Create the agent agents/employee-onboarding.md. Its job is to prepare the accounts, channels and first-week checklist for each new hire. It may use the Google Workspace, Linear and Slack connectors.

2. Create the skill skills/onboarding-checklist/SKILL.md with these rules:
   - A new hire is anyone newly added to the Pending Onboarding group in Google Workspace. Work each hire as its own case, so one failure never blocks another.
   - Read memory/onboarding-standard.md for the groups, aliases, Slack channels and checklist of each role. If a role is missing, use the closest match and flag the gap.
   - Plan the mailbox, aliases and group memberships. Creating the account and adding the groups need my approval first.
   - Invite the hire to their team's Slack channels without approval.
   - File a first-week checklist in the Onboarding project in Linear without approval.
   - Post the result to #it-ops: what is done, what waits for approval and what failed.

3. Add a cron trigger onboarding-check to kortix.yaml. It runs the employee-onboarding agent every hour, on the hour, with the prompt "Load the onboarding-checklist skill and onboard every new hire in the Pending Onboarding group."

4. Tell me which of these connectors are not connected yet.

5. Open a change request with all of it. Do not merge it.
```

### Connect your tools

Open **Connectors** in your workspace and connect Google Workspace, your task
tracker and Slack. Credentials are brokered server-side and never enter the agent's machine.

- **Google Workspace** (Required):
Finds new hires and prepares accounts, aliases and groups.
- **Linear** (Required):
Files the new hire's first-week checklist.
- **BambooHR** (Optional):
Marks the new hire who is ready to onboard.
- **Slack** (Required):
Adds the hire to team channels and posts the prepared setup.

### Run it once with this prompt

Merge the change request, then start a session with the **employee-onboarding** agent
and send this prompt. Check the planned account and the
checklist before you let the schedule take over.

**Prompt**

```
Run the onboarding check once.

1. Find people newly added to the Pending Onboarding group in Google Workspace. Treat each one as its own case.
2. Read memory/onboarding-standard.md for each hire's role and team.
3. Plan the mailbox, aliases and group memberships, and ask me before you create the account or add any group.
4. Invite each hire to their team's Slack channels.
5. File a first-week checklist in the Onboarding project in Linear.
6. Post the result to #it-ops with every step done, pending or failed.
```

### Let the hourly schedule take over

The change request added this trigger to `kortix.yaml`. From now on the agent
runs every hour, on the hour, each run in a new session on its own cloud
computer.
To change the time, edit the cron line, or open **Triggers** in the workspace.

**kortix.yaml**

```yaml
triggers:
  - slug: onboarding-check
    name: New-hire onboarding check
    on:
      cron: "0 0 * * * *"
    run:
      agent: employee-onboarding
      prompt: Load the onboarding-checklist skill and onboard every new hire in the Pending Onboarding group.
```

### Hold account creation for approval

Slack invites and the Linear checklist run on their own, because they grant no
system access. Creating the Workspace account and adding groups stop for a
person. An automated session waits at most 30 minutes for a person, then stops
without creating the account, and the next run asks again.

### Read the setup report

Each new hire ends as one report in #it-ops. This is what a run looks like in
the session:

> **New-hire onboarding check · 11:00**
>
> Prompt: Load the onboarding-checklist skill and onboard every new hire in the Pending Onboarding group.
>
> Found **2** new hires. Added each one to **4** team channels and filed **6**
> first-week issues in Linear. Both Workspace accounts are waiting for approval,
> each with a planned mailbox and **3** groups.

> **The pattern**
> Connect the HR record via a **trigger**, give the agent scoped **connectors**
> into Google Workspace, Slack, and Linear, encode the onboarding standard as
> **skills** and **memory**, and gate account creation and group membership
> behind a human.

## Make it do more

Once it works, paste any of these into the same session.

**Day-one welcome**

```
On each hire's start date, send them a Slack DM with the link to their first-week checklist and the name of their manager.
```

**Request a laptop**

```
When a role needs a laptop, file a hardware request in the Onboarding project with the start date as the due date.
```

**Check in after week one**

```
Seven days after the start date, ask the manager in Slack which first-week items are still open, and update the Linear checklist.
```

## Guardrails

Giving an agent the ability to create accounts and grant access is a trust
question. The relevant controls on Kortix:

- **Isolation.** Every new hire runs in its own isolated sandbox on its own
  branch. The session is granted access only to the systems it's scoped to, and only what
  it's explicitly allowed to send is written back out.
- **Scoped secrets.** Each credential is encrypted in the secrets manager,
  injected into the sandbox at runtime, and scoped to the agents you grant them to or the
  logs.
- **Human approval gate.** Account creation and group membership require a person
  to approve before anything is provisioned.
- **Everything is code.** The agent's persona, skills, and per-system
  permissions are files in the repo — versioned and changed through a reviewed
  **change request**, not a dashboard setting.

## The outcome

- **Day one:** Accounts and access prepared before the hire starts
- **Approval-gated:** Every account and group membership confirmed by a person
- **3 systems:** Google Workspace, Slack, and Linear — one agent

The scramble to set up a new hire across several tools now arrives as one
prepared, reviewable setup the moment their record exists, with the
access-granting steps held for a person. Extending it to another system means
connecting one more platform.
