> ## Documentation Index
> Fetch the complete documentation index at: https://docs.embedder.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Headless overview

> Trigger Embedder from GitHub and Slack and let a daemon on your own machine execute the work autonomously

Headless mode lets your team hand work to Embedder without opening a terminal. Mention `@embedder` on a GitHub issue or pull request, or message `@Embedder` in Slack, and a background daemon running on your own hardware picks up the request, executes it, and reports back — as a pull request, a GitHub comment, or a Slack reply.

## The three pieces

| Piece          | What it does                                                                                                    | Where you set it up                                                                            |
| -------------- | --------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------- |
| **GitHub App** | Turns `@embedder` mentions on issues and PRs into work items, posts results back, and runs automatic PR reviews | [Dashboard](https://app.embedder.com) → **GitHub**, see [GitHub integration](/headless/github) |
| **Slack app**  | Turns `@Embedder` messages into work items and streams progress into the thread                                 | [Dashboard](https://app.embedder.com) → **Slack**, see [Slack integration](/headless/slack)    |
| **Daemon**     | A background `embedder` process on your machine that claims queued work and executes it                         | Your terminal, see [Run the daemon](/headless/daemon)                                          |

The GitHub App is the foundation: Slack requests also run against repositories you connect through it, so set up GitHub first.

## How a request becomes a result

<Steps>
  <Step title="Someone triggers work">
    A teammate comments `@embedder fix the flaky I2C init` on a pull request, or asks the same in a Slack channel.
  </Step>

  <Step title="The backend queues a work item">
    Embedder resolves which repository the request targets and which project is mapped to it, then queues a work item for that repository. Repositories are mapped to Embedder projects in the dashboard — unmapped repositories are ignored.
  </Step>

  <Step title="Your daemon claims it">
    Any online daemon whose user has access to the mapped team claims the item. On GitHub, the triggering comment gets a 🚀 reaction; in Slack, the thread shows **Working on it**.
  </Step>

  <Step title="The daemon executes on your machine">
    The daemon fetches the repository into an isolated git worktree, selects the mapped team and project (so the agent has your hardware context — datasheets, peripherals, board configuration), and runs the agent with tool confirmations auto-approved. Slack requests stream progress into the thread as the agent works.
  </Step>

  <Step title="Results flow back">
    When the agent finishes, the daemon commits and pushes a branch, and the backend opens or updates the pull request and posts the completion comment or Slack reply. If the agent needs input instead, it asks a follow-up question in the same GitHub thread or Slack thread, and resumes when you reply.
  </Step>
</Steps>

## What runs where

Headless work executes on **your machine**, not on Embedder's servers:

* The daemon makes **outbound connections only** — a WebSocket to the Embedder backend plus HTTPS polling. It listens on no ports.
* Repositories are fetched with **short-lived, per-work-item GitHub tokens** minted by the backend. The daemon machine needs no GitHub credentials, no `gh` CLI, and no pre-existing clone of the repository.
* Each work item runs in a **fresh, isolated git worktree** under `~/.embedder` — your local checkouts are never touched.
* Because the daemon runs on your hardware, headless work has access to your **connected devices**: it can build, flash, and verify firmware over serial while executing a GitHub issue or Slack request.

Commits made by headless work are authored as `Embedder Agent <bot@embedder.dev>`.

## Set it up

<CardGroup cols={2}>
  <Card title="GitHub integration" icon="github" href="/headless/github">
    Install the GitHub App and map repositories to Embedder projects.
  </Card>

  <Card title="Slack integration" icon="slack" href="/headless/slack">
    Connect your Slack workspace so anyone can start work from a thread.
  </Card>

  <Card title="Run the daemon" icon="server" href="/headless/daemon">
    Start and monitor the daemon that executes the work.
  </Card>

  <Card title="Headless server mode" icon="plug" href="/integrations/headless-server">
    Drive Embedder programmatically over JSON-RPC instead.
  </Card>
</CardGroup>