Team settings

The seven pages of the Team tab and every setting of a team policy with type, default and allowed values.

Every team has exactly one policy. It decides which repositories and paths kanman may touch, which executor and models it uses, how much it may spend, and how much work runs in parallel. For the ideas behind it, read Policies. When kanman merges is not a policy setting: it merges only when CI and an independent review passed, and your code host’s own rules apply on top; see Merging.

You edit the policy in the app under Teams, your team, Team. The Team tab has seven short pages in two groups. Each page fits one screen: every setting is one line with a one-sentence explanation, its current value and a Default mark while it still has its default. Pressing a line opens its editor in a side panel; rarely used options sit in a More options fold. Every change saves at once, with a Saved tick and Undo.

The Team tab

Group Page Path What it holds
Ground rules Team /<workspace>/teams/<team>/team/team How kanman works with the team, people, labels, name and look
Ground rules Hours .../team/hours The team’s week, quiet hours in chat, reachability
Ground rules Budget and limits .../team/limits How much kanman takes on and spends, and what it must not change
Setup Models .../team/models Coding tool, model access, models for helpers, weekly pace
Setup Environment .../team/environment Variables, logins and secrets of every run, the image and internet access
Setup Repositories .../team/repositories The code kanman may change and the tracker the stories come from
Setup Connections .../team/connections Systems, accounts, chats, tools and alert sources for this team

Old links (/team/agent, /team/checks, /team/work, /team/chat, /team/api and others) redirect to the page that holds the setting now. Memory and skills, knowledge sources and the services catalog are not team settings: they live on the Mind tab under Memory (see Memory and skills). Connecting Claude Code or Codex on your own machine and personal API tokens are under Your settings > API tokens (see MCP).

Team

Setting What it does Default Key
How I work with this team Whether kanman is the team or works alongside your people, and who owns which area. Changes what kanman picks up on its own. I am the team
People Who belongs to the team. Only members ask kanman for team work and get its questions. The person who created the team
Labels The labels stories on this team’s board can carry. None
Name, key and look (More options) Name, story key and wallpaper of the team. Deleting the team is here too. Set when the team is created

Hours

Setting What it does Default Key
The week (When I start new work) The working days and hours in which kanman starts new work and asks. Drag the ends of a band or switch a day on or off. Any time working_hours
Quiet in chat Hours without unprompted replies in the team’s chats. Off
Reachability (fold) How quickly kanman answers a mention or reviews a requested merge request, and what waits until the hours start. 4 h, 8 h, hold until the hours start reachability

Budget and limits

Setting What it does Default Key
Stories at the same time How many stories kanman works on in parallel. More finishes sooner and costs more per day. 1 max_concurrency
Spend limits What one story, a day and a month may cost. kanman tells you at 80 % and stops at the limit. Budgets per person and goal sit in its fold. 2.00 EUR a story, no day or month cap budget_run_cents, budget_day_cents, budget_month_cents
Approval before merge Whether a person must approve kanman’s merge requests before they merge. Workspace default
What I must not change Protected paths and the largest change kanman may make in one story. No protected paths, 30 files, 800 lines denied_paths, max_changed_files, max_changed_lines
What I may create (More options) New repositories, branches and version tags on your code host. Off means kanman asks first. Ask first steward_can_create
How changes roll out (More options) How one change spreads over many repositories: a pilot first, then waves. Pilot on 2, then 10 % a wave
Ask me after this many failed checks (More options) After this many failed checks on one story kanman stops and asks. 3
How often I check on long runs (More options) How often kanman looks at a long run for loops or stalls, in minutes. 15
Reviewers of my merge requests (More options) Ask a teammate to review kanman’s merge requests, and which reviewers count as bots. Off

With model access from your runner, Spend limits count minutes and runs instead of euros: 60 minutes a run, no day or month cap (budget_run_minutes, budget_day_runs, budget_month_runs).

Models

Setting What it does Default Key
Coding tool Writes and tests the code of each story. A fallback steps in if it crashes. Claude Code, no fallback executor, fallback_executor
Model access How the coding tool and kanman’s own steps reach a model, and who pays for it. kanman’s own steps can use other access. Through kanman (provider cost + 15 %) billing_mode, ai_config_id, assistant_billing_mode, assistant_ai_config_id
Models for helpers Which models kanman’s helpers may use. Smaller models are faster and cost less. Automatic
Weekly pace Spreads the team’s model use over the week, so it never runs dry mid-week. Boost lifts it for a while. Spread over the week
Live view from your runner (fold) People on your network watch a run live, straight from your runner. Off

Environment

Setting What it does Default Key
Model login (Variables) The team’s own model access on your runners, such as a Claude Code token. Without it the runner’s is used. The runner’s own
Code host tokens (Variables) GitLab or GitHub tokens this team’s runs use instead of the runner’s. The runner’s own
Other variables (Variables) Anything else the work needs, as you would set it on the runner. Values are never shown again. None
Registry logins (Variables) Read access to a private image registry, used only to pull this team’s image. None
Workspace secrets (Variables) Workspace secrets this team’s runs may read, by name. The values stay in Workspace settings. None secret_names
Image and setup (Where the work runs) The container, tools and setup commands every run starts from. Detected per repository
Internet access (Where the work runs) What runs may reach on the internet, including preview hosts. Your production stays unreachable unless you list it. Only what the work needs (workspace default)

Repositories

Setting What it does Default Key
Repositories The repositories kanman may change, with how it names branches. Everything else stays read-only. None allowed_repos
Tracker Where stories come from, with the status mapping and the pick-up label. Issues become stories and their status flows back. kanman is your tracker

Connections

Setting What it does Default Key
Connections (card at the top) The systems your workspace connected, as this team uses them. Open one to choose what this team maps and what kanman may do there. What the workspace connected
My accounts and mentions The bot accounts people mention or assign in GitLab, GitHub or Jira to hand kanman work. None
Chats The Slack or Microsoft Teams channels kanman belongs to for this team, and how it listens there. None
Tools I may use Extra tools (MCP servers) kanman may use for this team, such as Sentry or your wiki. None
Alert sources Monitoring, service catalog and incident systems (such as a ServiceNow feed) whose alerts wake kanman for this team. None
Webhooks (For developers) Start work on this team from other systems with a signed webhook. None

Not on a page

is_paused has no line: the pause button next to the team’s status line in the team header sets it (see is_paused). intake_scope has no line in the Team tab either; ask kanman in the team chat to change it. The built-in habits (code_review.people_mrs, maintenance, cadence, the daily update and the mention switches) are changed in the chat on the Automations tab (see Built-in habits).

billing_mode and ai_config_id are chosen when you set up the team. The keys on this page are the names kanman uses in the audit log and in the policy snapshot of every run.

Who can change it

Only workspace admins can change a policy; other members see the settings read-only. Every change increases the policy version by one and writes a policy_changed entry to the audit log with the changed values and the old and new version. Each run stores the policy it started with, so you can always see which rules applied to a run.

Scope

What kanman may touch.

allowed_repos

Type: array
Default: []
Allowed: {"provider": "github" or "gitlab", "repoFullName": "org/repo", "branches": ["main"]}

Repositories and base branches kanman may work on. Branch entries are globs; a repository without a branch list allows any base branch. An empty list allows no repository at all. kanman does not work in a repository that is not listed.

The names of the branches kanman pushes are set next to the repositories, under Branch names (see Branch names).

denied_paths

Type: array of globs
Default: []
Allowed: Glob patterns, for example infra/**

Paths kanman’s helpers must not change. kanman checks them while a helper works (through check_policy) and again on the final diff. A change to a denied path is not pushed, and kanman says why in the activity log.

max_changed_files

Type: integer
Default: 30
Allowed: 1 or more

Maximum number of files one change may touch.

max_changed_lines

Type: integer
Default: 800
Allowed: 1 or more

Maximum added plus deleted lines of one change.

secret_names

Type: array of strings
Default: []
Allowed: Variable names

Names of the workspace’s secrets for runs this team’s runs may use. Edited under Team > Environment, Workspace secrets, as chips; the app suggests the names of the workspace’s secrets. A run gets the listed secrets that exist in the workspace as environment variables of the checks that need them; names the workspace does not have are listed in the run. Names kanman uses itself, such as model provider keys or PATH, are refused.

steward_can_create

Type: object
Default: {"repos": false, "branches": false, "tags": false}
Allowed: true or false per key

What kanman may create on the team’s code host on its own. Shown under Team > Budget and limits, More options, What I may create, as three switches. While a switch is off, kanman asks a person instead.

  • New repositories (repos): only in the group the team’s repositories already live in (for example my-company/integrations), never in another group or a personal account. The new repository is empty, gets the group’s visibility and is added to the team’s repositories at once.
  • New branches (branches): from an existing branch, tag or commit, or the first branch of a new, empty repository. An existing branch is never overwritten, so a base branch such as main or develop is only created where it does not exist yet.
  • Version tags (tags): only vX.Y.Z, only on a commit of the default branch whose checks passed, annotated with the story it belongs to. An existing tag is never moved.

kanman never deletes, renames or force-pushes anything, and every repository, branch and tag it creates appears in the team’s activity with the reason. Your code host account for kanman needs the rights to do this: for GitLab the Maintainer role in the group (Developer is enough when the group lets developers create projects), which also covers branches and tags; for GitHub permission to create repositories in the organisation.

Executor and routing

Which coding tool and models do the work.

executor

Type: string
Default: claude-code
Allowed: claude-code, codex

The coding tool that implements stories. Shown as Claude Code or Codex under Team > Models, Coding tool.

fallback_executor

Type: string or null
Default: null
Allowed: claude-code, codex

The executor that takes over when the main executor itself fails. If an attempt ends because the coding tool crashed or its model provider returned an error (not because a check failed, a budget or turn limit was reached, or a policy stopped it), kanman retries that attempt once with the fallback executor and its model for the story. The switch is noted in the run and recorded in the audit log as a policy decision. It happens only when the fallback can use the team’s model access: with your own key, Claude Code needs an Anthropic or Amazon Bedrock key and Codex an OpenAI or Azure OpenAI key.

routing

Type: object
Default: see below

Model tier and turn budget per complexity class, plus the reviewer settings.

Default value:

{
  "trivial":  { "modelTier": "small",    "turnBudget": 100 },
  "routine":  { "modelTier": "mid",      "turnBudget": 120 },
  "complex":  { "modelTier": "flagship", "turnBudget": 200 },
  "reviewer": { "vendor": "different_from_executor", "modelTier": "mid" },
  "modelOverrides": {}
}

Default models per tier:

Tier Claude Code Codex
small haiku gpt-5-mini
mid sonnet gpt-5
flagship opus gpt-5

The Claude Code names always point to the current model of that family. modelOverrides pins a model by complexity class (for example "routine"), by tier (for example "mid") or for the "reviewer"; a class entry wins over a tier entry. With "vendor": "different_from_executor" the reviewer uses the other vendor’s model of its tier, so code written by Claude Code is reviewed by a Codex model and the other way round.

The Team tab has no line for the routing per story size; the defaults above apply. Which models kanman’s helpers may use is set under Team > Models, Models for helpers. Teams created before 3 October 2026 keep the trivial budget of 60 steps they started with.

billing_mode

Type: string
Default: pass_through
Allowed: byok, pass_through, runner_env

How the executor reaches its model and who pays the provider: your own contract through a key saved in kanman (byok), kanman, billed at cost plus 15 percent (pass_through), or the model access of your self-hosted runner (runner_env, shown as Model access from the runner environment). With runner_env, kanman passes no model credentials to the run at all; it is offered only for workspaces whose runs execute on their own runners. kanman cannot see model cost in this mode, so the run and team budgets count minutes and runs instead of euros. Chosen in the team setup and under Team > Models, Model access.

ai_config_id

Type: reference or null
Default: null
Allowed: The key saved under Workspace settings > Model access

The provider key used with byok. Claude Code works with an Anthropic or Amazon Bedrock key, Codex with an OpenAI or Azure OpenAI key. With an AI gateway key, Claude Code needs the gateway’s Anthropic-compatible endpoint and Codex its OpenAI Responses API. A run with a missing, inactive or unsuitable key fails with a clear error instead of falling back to pass-through.

assistant_billing_mode

Type: string or null Default: null (same as billing_mode) Allowed: null, byok, pass_through, runner_env

How kanman’s assistant steps reach their model: drafting stories, replies in the conversation, the reviewer and the spec author. null (shown as Same as the coding tool) uses the coding tool’s billing_mode and key. Another value gives them their own model access, for example your company’s AI gateway key while the coding tool uses the runner environment. runner_env is offered only for workspaces whose runs execute on their own runners. Set under Team > Models, Model access, with My own steps use other access.

assistant_ai_config_id

Type: reference or null Default: null Allowed: The key saved under Workspace settings > Model access

The provider key of the assistant steps when assistant_billing_mode is byok. Cleared automatically for every other value.

Budgets

All amounts are in euro cents. Budgets are hard stops. Set under Team > Budget and limits, Spend limits, where meters show what was spent this month and today (or, with the runner environment, the runner’s limits in minutes and runs). Work with the class of service expedite and incident work is never stopped by budgets.

budget_run_cents

Type: integer
Default: 200 (2.00 EUR)
Allowed: 1 or more

Maximum cost of one run, across all attempts. When it is reached the run stops with Stopped: budget reached, no pull request is created, and kanman says so in the conversation.

budget_day_cents

Type: integer or null
Default: null (no limit)
Allowed: 1 or more

Maximum spend of the team per day, in the time zone of working_hours (UTC if none). When it is used up, no new run starts until the next day.

budget_month_cents

Type: integer or null
Default: null (no limit)
Allowed: 1 or more

Maximum spend of the team per calendar month, in the same time zone. When it is used up, no new run starts until the next month.

budget_run_minutes

Type: integer Default: 60 Allowed: 1 to 1440

Only with billing_mode runner_env: maximum time of one attempt in minutes. When it is reached the run stops with Stopped: the run used its 60 minutes (with your value), and no pull request is created. Euro budgets do not apply in this mode.

budget_day_runs

Type: integer or null Default: null (no limit) Allowed: 1 or more

Only with runner_env: number of runs the team may start per day, in the time zone of working_hours. When it is reached, no new run starts until the next day. Expedite and incident work still starts.

budget_month_runs

Type: integer or null Default: null (no limit) Allowed: 1 or more

Only with runner_env: number of runs the team may start per calendar month.

Working hours and concurrency

When and how much kanman works.

working_hours

Type: object or null
Default: null (always)
Allowed: {"tz", "days", "start", "end"}

When new runs may start, for example {"tz": "Europe/Berlin", "days": [1,2,3,4,5], "start": "08:00", "end": "19:00"}. Days are 1 (Monday) to 7 (Sunday). Runs in progress finish. Expedite stories and incidents start outside working hours too.

max_concurrency

Type: integer
Default: 1
Allowed: 1 to 20

How many runs of this team may be active at the same time, set as Stories at the same time under Team > Budget and limits; its meter shows which cap applies (team, plan or workspace). The effective value is capped by the team’s plan: Starter 2, Team 5 (also during the 14-day trial). On Local, no runs start in the cloud. Stories wait in Ready until a slot is free.

is_paused

Type: boolean
Default: false
Allowed: true, false

A paused team starts no new runs; runs in progress finish. Pause and resume with the pause button next to the team’s status line in the team header (Paused ยท Resume while paused); it takes effect at once and offers Undo. You can also ask kanman in the conversation, for example “pause Sandbox Team”, and confirm the change. While the team is paused, Team > Hours says since when.

reachability

Type: object or null
Default: null (the defaults below)
Allowed: {"responseHours": {"mentions", "reviews"}, "outsideHours", "dailyUpdate": {"enabled", "at", "where"}}

How reachable kanman is for the team, set in the Reachability fold of Team > Hours:

Key Default Meaning
responseHours.mentions 4 First answer to a mention, in working hours (1 to 72)
responseHours.reviews 8 First review of a requested pull or merge request, in working hours (1 to 72)
outsideHours "hold" hold: outside working_hours, pull and merge requests open as drafts and are marked ready when the hours start; reviews and Slack posts wait for the hours; no unprompted messages in Slack or Teams. anytime: no holding. Expedite stories and incidents are never held.
dailyUpdate.enabled false A short daily update on working days, only when there is something to say
dailyUpdate.at "09:00" Local time in the time zone of working_hours (UTC if none)
dailyUpdate.where "chat" chat (the team chat) or slack (the team’s Slack channel)

See Working hours and reachability.

Intake and maintenance

Who files work and how kanman keeps the team’s repositories up to date.

intake_scope

Type: string
Default: humans_and_kanman
Allowed: humans_only, humans_and_kanman

Who may file the stories kanman works on.

  • humans_only: kanman only works on stories people filed. kanman never files a story itself: with maintenance on, every finding waits as a proposal in Decisions, and only a person accepting it files the story.
  • humans_and_kanman: kanman may also file stories itself. With maintenance on, findings of the allowed kinds (allowedKinds) are filed as maintenance stories without asking; all other findings still wait as proposals.

Stories from intake are always approved by a person before they are written to the tracker, whatever this setting says.

maintenance

Type: object
Default: {"enabled": false, "dripPerDay": 0, "maxPerRun": 1, "allowedKinds": []}

Maintenance mode: on or off, how many maintenance stories and proposals may be filed and started per day, how many routine findings one scan may file at most (maxPerRun), how many new stories and proposals one scan may create in total, security included (newStoriesPerScan, 5 when not set), which kinds become stories without asking, and optionally the shared template repository (templateRepo) that group stories name. It is the built-in habit Keep dependencies and security current: switch it on or pause it in the chat. Started from the chat on a team without its own numbers, it uses the steady pace (2 a day, 1 routine finding and 5 new stories per scan, a scan every 7 days) with the kinds cve, outdated_dep, unused_dep, lockfile_drift and broken_doc_link. ciWatch: false pauses the built-in habit Watch main.

cadence

Type: object
Default: {"reportWeekday": 1, "scannerDays": 7}

Weekday of the team report (1 = Monday) and how often maintenance scanners run for the team, plus the team’s rituals, which are built-in habits: the weekly recap (weeklyRecap, false pauses it), the delivery review after the weekly report (deliveryReview) and the day of the retrospective prompt (retroWeekday, 0 = off).

Full example

{
  "version": 7,
  "allowed_repos": [
    { "provider": "github", "repoFullName": "acme/billing", "branches": ["main"] }
  ],
  "denied_paths": ["infra/**", "**/*.tf", ".github/workflows/**", "migrations/**"],
  "max_changed_files": 30,
  "max_changed_lines": 800,
  "executor": "claude-code",
  "fallback_executor": null,
  "billing_mode": "pass_through",
  "ai_config_id": null,
  "budget_run_cents": 300,
  "budget_day_cents": 3000,
  "budget_month_cents": 40000,
  "budget_run_minutes": 60,
  "budget_day_runs": null,
  "budget_month_runs": null,
  "working_hours": { "tz": "Europe/Berlin", "days": [1, 2, 3, 4, 5], "start": "08:00", "end": "19:00" },
  "max_concurrency": 2,
  "secret_names": [],
  "intake_scope": "humans_and_kanman",
  "maintenance": { "enabled": false, "dripPerDay": 0, "maxPerRun": 1, "allowedKinds": [] },
  "cadence": { "reportWeekday": 1, "scannerDays": 7 },
  "is_paused": false
}

Last updated: January 1, 0001

Open kanman