Skip to content

Rolling out a coding agent to your teams: the settings and the day-one checklist

Claude Code, GitHub Copilot, Cursor or Codex read your code, run commands and propose changes. The managed settings file to copy, with what each line does, a comparison of the four tools as of 26 October 2026, the day-one checklist, and how we frame the agent that builds this site.

By Published on 2 October 2026Updated on 26 October 2026

Where the coding agent acts, and where the checks areThe agent proposes on its branch; the checks and a person decide what goes to production.

The workstation, in the sandbox

The coding agent

Reads the repository, changes files, runs commands

  • Managed settings, enforced for all
  • Secrets and keys unreadable
  • Outbound traffic filtered
  1. Its branch

    The agent pushes here, never to the main branch

  2. The pull request

    Lint, tests, analysis

  3. The review

    By someone other than the person who started the agent

  4. The release

    Started by a person

Every action logged and sent to your monitoring

A coding agent (Claude Code, GitHub Copilot, Cursor, OpenAI Codex and their equivalents) does more than complete a line: it reads the repository, runs commands, changes files and opens pull requests. Before opening it to your teams, five decisions matter: the plan and what it says about your data, the settings imposed on everyone, what the agent can run, what is logged, and who reviews.

This guide gives the managed settings file we set up, line by line, a comparison of the four tools, the day-one checklist, and how we frame the agent that builds this site.

What a coding agent changes compared with autocompletion

Autocompletion suggests text, which the developer accepts or not. The agent acts on the workstation or in a remote environment with the rights it is given: it reads configuration files, runs scripts, installs dependencies, calls services. A booby-trapped file or ticket can then slip it instructions (prompt injection), and it has the means to carry them out. In April 2026, CERT-FR asked not to deploy autonomous assistants on workstations until they are proven, and never in production; the full list of guardrails is in our article on securing AI agents.

Claude Code, Copilot, Cursor, Codex: the comparison as of 26 October 2026

What each vendor’s documentation and terms say for a company plan. We read this table again every month: terms change.

Tool

Your data

Settings an administrator enforces

Sandbox

Logs

Claude Code

No training on code and prompts under commercial terms; standard retention of 30 days, zero retention on request for some Enterprise accounts

A managed settings file on workstations or settings pushed from the console: command rules, banned modes, MCP servers, models, sign-in to your organisation

Off by default; once enforced, writes limited to the working folder, outbound traffic filtered; macOS, Linux and WSL2, not native Windows

OpenTelemetry export to your monitoring, prompt text masked by default; Compliance API on Enterprise

GitHub Copilot

Business and Enterprise data excluded from training; since 24 April 2026, data from individual plans is used for training unless the user opts out

Organisation policies: cloud agent, models, MCP servers, public code, content exclusion; a managed settings file for the command line and the editors

The cloud agent works in an ephemeral environment, behind a firewall on by default, on its own branch

A 180-day audit log: policies and agent activity, without prompt text

Cursor

Privacy mode: no training, zero retention at the model providers, flagged exceptions aside; on by default on Enterprise

Privacy mode enforced for the team, allowed models, an MCP server list, command run modes

A sandbox for commands, internet access blocked by default; macOS and Linux

Audit logs on Enterprise, without prompts or code

OpenAI Codex

No training by default on Business, Enterprise and API data

A requirements file users cannot lift: allowed approval and sandbox modes, MCP servers, command rules

An operating-system sandbox, internet access off by default locally

Compliance API on Enterprise; optional OpenTelemetry export

The rule that follows: company accounts only, never a personal account on company code, and sign-in limited to your organisation.

Claude Code’s managed settings file, line by line

These settings apply to everyone: no user or project file lifts a managed key. The file goes in /Library/Application Support/ClaudeCode/managed-settings.json on macOS, /etc/claude-code/managed-settings.json on Linux and WSL, C:\Program Files\ClaudeCode\managed-settings.json on Windows, or is pushed from the admin console on Team and Enterprise plans. The one we start from:

JSON
{
  "permissions": {
    "deny": [
      "Read(./.env)",
      "Read(./.env.*)",
      "Read(./secrets/**)",
      "Read(~/.ssh/**)",
      "Read(~/.aws/**)",
      "Bash(git push --force *)",
      "Bash(terraform apply *)"
    ],
    "ask": [
      "Bash(git push *)",
      "Bash(npm publish *)"
    ],
    "allow": [
      "Bash(npm run lint)",
      "Bash(npm run test *)",
      "Bash(git status)",
      "Bash(git diff *)"
    ],
    "disableBypassPermissionsMode": "disable"
  },
  "allowedMcpServers": [
    { "serverUrl": "https://mcp.your-company.example/*" }
  ],
  "sandbox": {
    "enabled": true,
    "failIfUnavailable": true,
    "allowUnsandboxedCommands": false,
    "network": {
      "allowedDomains": ["github.com", "*.npmjs.org"]
    },
    "credentials": {
      "files": [
        { "path": "~/.aws/credentials", "mode": "deny" },
        { "path": "~/.ssh", "mode": "deny" }
      ],
      "envVars": [
        { "name": "GITHUB_TOKEN", "mode": "deny" }
      ]
    }
  },
  "forceLoginMethod": "claudeai",
  "forceLoginOrgUUID": "00000000-0000-0000-0000-000000000000",
  "env": {
    "CLAUDE_CODE_ENABLE_TELEMETRY": "1",
    "OTEL_METRICS_EXPORTER": "otlp",
    "OTEL_LOGS_EXPORTER": "otlp",
    "OTEL_EXPORTER_OTLP_ENDPOINT": "https://otel.your-company.example"
  }
}

Setting

What it does

permissions.deny

Refuses, whatever happens: reading secret files and keys, force-pushing, applying infrastructure. Deny rules are read first, and no other level can allow what they deny.

permissions.ask

Asks for confirmation before pushing code or publishing a package.

permissions.allow

Lets harmless commands through without a question: lint, tests, reading history.

disableBypassPermissionsMode

Bans the mode that removes every confirmation (the --dangerously-skip-permissions flag is refused).

allowedMcpServers

Allows only the listed MCP servers, by address or command: the documentation states that a server name alone is not a control.

sandbox

Enforces the sandbox for commands, refuses to start without it, forbids running a command outside it again, limits outbound traffic to the listed domains and makes credential files unreadable.

forceLoginMethod, forceLoginOrgUUID

Only an account of your organisation can sign in.

env

Sends metrics and events (sessions, permission decisions, costs) to your monitoring through OpenTelemetry; a repository cannot switch these exports on itself.

Two limits, written in the documentation itself. A rule on a command guides the agent but is not a barrier: Bash(git push *) does not stop git -C . push. The barrier is the sandbox, which applies to commands only: the file read and write tools follow the permission rules. And these settings remain a workstation control, not a security boundary: the main branch must be protected on the code platform, whatever happens on the workstation.

The equivalent in GitHub Copilot

  • The cloud agent (formerly the coding agent) is off by default on Business and Enterprise: open it to chosen organisations and repositories only.
  • Models are allowed one by one.
  • MCP servers have their own policy; for the cloud agent, they are set repository by repository, and the agent uses their tools without asking for approval: connect only servers with very limited rights.
  • Suggestions matching public code can be blocked.
  • Content exclusion does not apply to the Edit and Agent modes of chat in the editors: it does not replace rights on the repository.
  • A managed settings file also exists for the Copilot command line, VS Code and the Copilot app, with, depending on the tool, the same families of rules: commands, the no-confirmation mode, sandbox, MCP servers.

The day-one checklist

  1. Company accounts only, and sign-in limited to your organisation.
  2. The managed settings file deployed on workstations, or pushed from the console, before the first launch.
  3. The sandbox on and enforced, reading secrets and keys denied.
  4. No production credentials on workstations; tokens dedicated to the agent, limited to the repository and the actions it needs.
  5. The list of allowed MCP servers, by address or command.
  6. The main branch protected: pull request, automatic checks, review by a person other than the one who started the agent.
  7. Metrics and events sent to your monitoring.
  8. An hour with the team: what the agent can and must not do, how to review its change, spotting an injection in a ticket or a file, the data you never paste into a prompt.
  9. An owner for these settings, and a date to review them.

Human review stays mandatory

ANSSI and its German counterpart, the BSI, wrote it as early as October 2024: coding assistants do not replace experienced developers, and generated code must be checked. GitHub’s cloud agent applies this principle by design: it pushes to its own branch, cannot approve or merge its pull requests, the person who started it cannot approve them, and pipelines only run after a person agrees.

Whatever the tool: protected branches, mandatory tests and security analysis, and human review before any merge, which our offer Flaws caught before release sets up. Our page Automate software development describes how we bring agents into your toolchain with these approvals, and our article on DevSecOps the checks to plug in.

How we frame the agent that builds this site

This site is written and maintained by a coding agent, under rules we wrote for it. What is in place today:

  • written rules the agent reads again: the site’s content rules and its architecture decisions;
  • automatic checks before every proposal: the linter, which also carries the content rules (it refuses an em dash, for instance), the integration and end-to-end tests;
  • a mandatory pull request for every change to the main branch, reviewed on the local site and merged by a person;
  • a release started by a person, with a check before and after.

Next, prepared and under review: applying to the site’s repository what this guide recommends, meaning project settings that deny reading secret files, deploying and force-pushing, the sandbox, a barrier against pushing secrets, dependency alerts, and a pipeline that runs the linter and tests again on every pull request.

Going further: our articles on MCP servers and on vibe coding, and the page Agentic AI.

Frequently asked questions

Can the agent read our whole repository?

By default, it reads what is reachable from its working folder, and most of the disk for commands, credential files included. Deny rules, the sandbox and its credential protections narrow that scope.

Is our code used to train the model?

Not with the company plans of Claude Code, GitHub Copilot, Cursor and Codex, according to their terms as of 26 October 2026. Individual plans can work differently: one more reason to keep them away from company code.

Claude Code, Copilot or Cursor: what criteria to choose on?

The terms on your data, the settings an administrator can enforce, the sandbox, the logs, and integration with your code platform and your delivery pipeline. The right choice is the one you can frame.

Should autonomous mode be banned?

The mode that removes every confirmation, yes, except in an isolated, disposable environment. A mode where the agent moves on its own for harmless actions and asks for the rest can be justified, if it is framed by managed settings and the sandbox.

Sources

Written with an AI assistant from the sources cited, facts checked and reviewed by Mehdi Chafik on 26 October 2026.