Run everything on your runners
Keep all model traffic and every repository action inside your network: kanman's cloud keeps the board, decisions and the audit log, and your self-hosted runners do the rest.
With a self-hosted runner, the coding work of a run happens in your network. A few steps around the run still happen in kanman’s cloud by default: drafting stories from a requirement, the independent review, writing acceptance specs, the maintenance scans, and repository actions such as opening the pull request or posting the evidence pack.
Everything on ours (also called running everything on your runners) moves all of these onto your runners as well. kanman’s cloud then never calls a model provider and never reads or writes one of your repositories for the workspace. Neither source code nor model traffic passes through kanman.
Your own runners and this option are available from the Starter plan, and during the 14-day Team trial. See Plans and billing.
Turn it on
- Start at least one self-hosted runner and give it the model access and the code host token described below.
- Open Workspace settings > Runs and runners (
/settings/runs). - Under Where runs execute, choose Everything on ours. kanman asks first: it names the work that moves to your runners and says that work waits while no runner is online. Confirm with Run everything on ours. Owners and admins can change it; the change is recorded in the audit log (export format).
The diagram Where things run on the same page then shows runs, checks, model calls, repository actions and chat replies on your network’s side. To go back, choose Our runners or kanman Cloud.
What your runners need
| Variable | Meaning |
|---|---|
KANMAN_API_KEY |
The workspace API token, as for every runner |
| Model access | The provider variables of your account, for example Amazon Bedrock, Google Vertex AI, Microsoft Foundry, Azure OpenAI, or an Anthropic or OpenAI key. One configuration covers every step: the coding agent and kanman’s own steps (drafts, review, acceptance specs, replies) use the same access, for example Amazon Bedrock through the runner’s IAM role. See Model access on self-hosted runners. Teams that use their own key in kanman get that key for each step instead, and a team can bring its own model access to the runner (Several teams on one runner). |
GITHUB_TOKEN |
Token for GitHub or GitHub Enterprise repositories (GITHUB_API_URL for GitHub Enterprise) |
GITLAB_TOKEN |
Token for gitlab.com or your self-managed GitLab (GITLAB_API_URL, for example https://gitlab.example.com/api/v4) |
SHAREPOINT_TENANT_ID, SHAREPOINT_CLIENT_ID, SHAREPOINT_CLIENT_SECRET |
Optional. An app registration of your organization for SharePoint sources in the team context, see Set up SharePoint |
CONFLUENCE_URL, CONFLUENCE_EMAIL, CONFLUENCE_API_TOKEN |
Optional. A Confluence account and its API token for Confluence sources in the team context |
NOTION_TOKEN |
Optional. A Notion internal integration for Notion sources in the team context |
TEMPO_TOKEN (or TEMPO_USERNAME and TEMPO_PASSWORD) |
Optional. Access to your Grafana Tempo for incident investigations |
BACKSTAGE_TOKEN, CHECKMK_USERNAME and CHECKMK_SECRET |
Optional. Read your Backstage catalog and Checkmk when a source leaves the token to the runner (Backstage and Checkmk) |
RUNNER_JOBS |
Optional. Comma-separated list of the step kinds this runner takes, for example to keep acceptance checks on one larger host. Default: all it can do. |
RUNNER_JOB_CONCURRENCY |
Optional. How many short steps (drafts, reviews, repository actions) the runner works on next to its runs. Default 2. |
The runner keeps the tokens to itself. kanman’s cloud does not need, and in this mode does not use, a token for your code host.
Because kanman’s cloud does not list your code host’s projects in this mode, the team setup and Team settings > Repositories and tracker add a repository by its host URL and path, and your runner checks that it reaches it. For a GitLab that is only reachable inside your network, see GitLab behind a VPN or firewall.
Different models for coding and for the other steps
The runner can give kanman’s own steps another model than the coding agent, for example Claude for coding and your company’s OpenAI-compatible AI gateway for drafting, review and replies. Set the KANMAN_ASSISTANT_ variables on the runner; see Different models for coding and for the other steps.
A gateway that is reachable only inside your network can also be stored in kanman as the workspace’s provider key (Use a gateway or proxy instead in Workspace settings > Model access): in this mode only your runners call it, internal addresses are accepted, and Test connection runs on your runner. See Use your company’s AI gateway and AI gateways in the runner environment.
What runs where
| Step | Where it runs |
|---|---|
| Coding runs, local verification, push and the pull or merge request | Your runner |
| Acceptance checks (spec run, fresh environment, clean checkout) | Your runner |
| Writing the acceptance spec and the independent reviewer | Your runner, with your model access. The runner reads the diff from your repository itself. |
| Drafting stories from the conversation, and drafts from chat | Your runner, with your model access |
| Comments with the evidence pack, commit statuses, CI results, merges | Your runner, with its code host token |
| Acceptance manifest check and the starter pull request | Your runner |
| Maintenance scans, the read-only reviewers, strategy proposals | Your runner |
| Grouping review notes into conventions | Your runner |
| Team context from every source (links, repositories with their issues and pull requests, Confluence, Notion, SharePoint, uploaded files), and answers from team context | Your runner |
| Log and trace reads for incidents (Kubernetes, Loki and Tempo) | Your runner |
| GitHub or GitLab issues as the team’s tracker: pickup, status labels, comments and pull request links | Your runner, with its code host token |
| Revert requests when a kanman merge turned main red or caused an incident, and merging or closing them from the decision | Your runner, with its code host token |
| Board, policies, decisions, the audit log, run status, reports | kanman’s cloud |
Exactly what reaches kanman’s cloud
kanman’s cloud stores only the orchestration state and what your runners send back:
- the stories you write or approve (title, description, acceptance criteria, Demonstrate block), decisions, policies and settings,
- run status, progress lines and the first line of each of the agent’s status messages (no tool inputs or outputs, no transcript of the agent’s work), cost and the evidence pack: test and check results, the reviewer’s verdict per criterion with file and line references, links to the pull request and to CI,
- the names and line counts of changed files and the commit list of a run (no file contents),
- the text a runner sends back for kanman’s own steps: drafted stories, the acceptance spec it wrote, the reviewer’s verdict, maintenance findings, strategy proposals and answers,
- the audit log, including one entry for each step a runner completed (the step, the runner, the result and, for model steps, the tokens and the estimated model cost). A model call kanman makes in its cloud is recorded too (“Model called in kanman’s cloud”), so the log proves that none happened: ask kanman “Show me the runner jobs in the audit log” or “Show me the cloud model calls in the audit log” to open it filtered.
To build the prompts for these steps, kanman sends your runner what it already stores (for example a story and its acceptance criteria) and the names of the files or refs to read. The runner adds the repository content itself. Code never travels to kanman, and kanman never calls a model provider for the workspace.
When no runner is online
Work waits. Nothing falls back to kanman’s cloud.
- When you open kanman while your runner is offline and work waits for it, kanman says so first in your conversation: which runner, since when (in your time zone) and how many steps wait, for example “Your runner build-box-1 has been offline since Oct 3, 2026, 8:53 AM; 2 steps wait for it.” Once the runner is back, everything goes on by itself.
- When steps wait for a free runner, a small badge at the end of the team’s status line says Waiting for a runner. Hover over it (or tap it, or press Enter) to see how many steps wait and a link to Workspace settings > Runs and runners. When no runner is online, a notice in your conversation says so, with the same link.
- A requirement you send in the conversation shows that it waits for your runner. As soon as a runner answers, the drafts appear in the same message.
- A run whose review waits for the runner is parked with Waiting for your runner; it continues when the runner answers, without using up an attempt.
Limits
- Answers limited to Only people with access in the source use Confluence page permissions only when the source has a Confluence connection in kanman; SharePoint files shared with a group need a SharePoint connection in kanman for that check, otherwise only people the file is shared with directly get answers from it.
- Incident log reads from Datadog, CloudWatch and Sentry, and traces from Datadog APM, are not available on the runner yet; Kubernetes, Loki and Tempo work.
- Repository actions on hosts other than GitHub and GitLab are not supported in this mode yet.
Related pages
Last updated: January 1, 0001
Open kanman