Keeping company standards consistent across coding tools requires separate controls for distributing instructions, enforcing permissions, and verifying repository changes.
Developers use Codex, Claude Code, and Cursor on laptops and remote machines. Even with identical instruction files, plugins, authentication, and local settings can change the tools available and the results.
This becomes harder across multiple teams. A payments team needs reconciliation rules, while a web team needs UI verification procedures. Common security policies must apply to both and remain in effect after tool updates.
This article examines configurations and responsibilities at 12 companies using official sources checked through October 2, 2026. The company diagrams reconstruct their published accounts; they are not internal deployment diagrams. The later sections on responsibilities and updates propose designs drawn from these cases.
What to manage centrally
An agent harness supplies context to the model and manages tool calls and task state. Organizations add installation, policies, internal knowledge, evaluation, and deployment around it. Supporting several products requires deciding which of these operations must remain consistent.
| Area | Standard to maintain | How to check |
|---|---|---|
| Instructions and business knowledge | Approved common standards and the team's knowledge | File versions and actual loading results |
| Skills and plugins | Reviewed procedures and executable code | Installation source, version, and required permissions |
| System access | Scope permitted for the user and task | Execute requests that should be allowed and denied |
| Result verification | Success criteria for each repository | Build, test, and review results |
| Updates | Existing workflows and required restrictions | Regression checks by product, OS, and execution environment |
Matching file contents addresses the first check. Whether a product reads the file, conflicting settings exist, or prohibited actions are blocked needs separate verification. The table does not promise identical model-generated code.
Public sources also establish different things. Engineering accounts describe operational configurations; vendor customer stories describe adoption as reported by the customer. Product documentation describes available capabilities and should be distinguished from evidence of a company's deployment.
Uber's shared execution environment and service ownership
The operating architecture published in August 2026 uses a common wrapper for each interactive coding harness. It manages installation, configuration, authentication, and usage visibility, while developers author task-specific skills. Uber reported more than 3,600 skills and 30,000 daily executions at publication.
flowchart TD
W["Common wrapper<br/>Installation, configuration, authentication"] --> A["Coding harnesses used by developers"]
A --> G["MCP Gateway<br/>Caller identity and permissions"]
T["Service owners<br/>Review tool and description changes"] --> R["Registry<br/>Definitions, policies, change history"]
R -->|Enable after review| G
G --> S["Tools from each service"]
D["Automatically discovered tools"] -->|Register as disabled| R
Model selection uses internal benchmarks based on real PRs. The same operating framework tracks task results and the effects of model changes alongside shared installation. The figures describe Uber's reported usage, not productivity gains at other companies. Uber's development platform operations, 2026-08-27
The MCP architecture published in October separates the Registry and Gateway. The Registry manages tool definitions, owners, policies, and change history; the Gateway handles authentication, authorization, and responses. It centrally connects more than 5,000 tools, while service owners review their business meaning and whether to expose them.
Automatically discovered tools are registered as disabled. Description changes undergo owner review, deployment, and rollback procedures, and calls distinguish human, service, and agent identities. Platform operations are shared while responsibility for tools remains with each service. Uber MCP Gateway design, 2026-10-01
BlackRock's bread-kit and shared knowledge distribution
bread-kit stands for BlackRock Enterprise Agentic Development Kit. It provides development standards, architecture guidance, domain knowledge, and skills across development tools.
It manages ownership and versions in Git, combining reviewed company knowledge with team and repository context. The management history of that knowledge persists when tools change.
flowchart TD
C["Reviewed company standards"] --> G["Git<br/>Ownership and version management"]
T["Team and repository knowledge"] --> G
G --> B["bread-kit<br/>Shared context and skills"]
B --> A["Development tool A"]
B --> D["Development tool B"]
B --> N["New engineer onboarding"]
In Cognition's customer story, the responsible BlackRock executive says all coding teams adopted it and use it to onboard new engineers. This is a customer account published by a vendor. It does not establish that BlackRock deployed every Devin Plugins management feature announced in the same article.
Exact user counts, IAM implementation, and version promotion procedures are undisclosed. The evidence establishes shared knowledge management in Git and distribution across tools. BlackRock bread-kit case, 2026-09-09
Stripe's Minions and defined execution procedures
Minions is an internal coding agent built on Block's Goose. Its Blueprints connect agent decisions with deterministic steps such as linting and pushing. It reads Cursor rules scoped by directory and file pattern, and Stripe synchronizes those rules for Claude Code too.
flowchart TD
R["Task requests from Slack and other entrypoints"] --> B["Blueprint<br/>Manage execution order"]
C["Shared Cursor rules"] --> M["Minions<br/>Edit code in isolated devboxes"]
T["Toolshed<br/>Select tools for the task"] --> M
B --> M
M --> V["Lint, CI, and bounded repair attempts"]
V --> H["Return results for engineer review"]
Tasks receive a relevant subset of roughly 500 tools in the internal Toolshed MCP server. Prepared devboxes restrict access to production services, real user data, and unrestricted external networks. Local linting, CI, and bounded repair attempts precede returning results to a human. Stripe Minions Part 2, 2026-02-19
Requests start in existing collaboration workflows such as Slack and lead to review by the requesting engineer and another engineer. The amount of agent-written code and the scope of human review require separate interpretation. Stripe Minions Part 1
Spotify's Honk and repository-specific verification
Honk adds code transformation to Fleet Management/Fleetshift's existing repository selection, scheduling, PR creation, review, and merge workflow. Multiple entrypoints reuse the common CLI, logging, and tracing. The development platform that preceded agents continues to handle surrounding tasks. Honk Part 1, 2025-11-06
flowchart TD
F["Fleet Management<br/>Repository selection and scheduling"] --> H["Honk<br/>Code transformation"]
H --> V["Repository-specific verifier<br/>Builds and checks"]
R["Repository verification criteria"] --> V
V -->|Verification passes| J["Judge<br/>Compare request and change"]
J -->|Passes| P["Fleet PR workflow"]
V -->|Verification fails| S["Block PR creation"]
J -->|Veto for scope drift or other issues| S
Repository contents determine which verifiers run, with different build and check procedures behind a common verifier interface. After those checks, a judge compares the request and changes. Failed verification or a judge veto blocks PR creation. The surrounding platform handles pushing and Slack integration.
The article explicitly says the judge's own performance had not yet been evaluated. Adding a verification step and establishing that its judgments are reliable require different evidence. Honk Part 3, 2025-12-09
The follow-up architecture published in June 2026 uses the Claude Agent SDK, Spotify's harness, and Kubernetes. It connects tasks to Backstage component ownership, documentation, and existing development standards, and uses CI for feedback. The limitations of the 2025 implementation and the 2026 architecture describe different points in time. Spotify's development environment for teams and agents, 2026-06-03
Block's company and module checks
Block provides a common sq agents review entrypoint on developer machines and in the cloud. It runs module owners' checks in .agents/checks/*.md alongside company checks. Nested AGENTS.md files supply code context, and an internal Skills Marketplace shares procedures.
flowchart TD
G["Company checks"] --> R["sq agents review<br/>Developer machines and cloud"]
M["Module owners<br/>.agents/checks/*.md"] --> R
A["Nested AGENTS.md<br/>Code context"] --> R
R --> O["Independent review agent per check<br/>Run in parallel and aggregate results"]
O --> H["Human code review and approval"]
I["Changes proposed from incidents and announcements"] --> V["Human review of policy changes"]
V --> M
V --> G
Each check runs in parallel through a review agent with independent context, and the results are combined. Incidents and announcements can prompt policy and check proposals, but humans review changes and give final code approval. The platform handles shared execution and result collection; teams familiar with the code manage check contents. Block's check and skill operations, 2026-04-02
Meta's performance optimization team and domain skills
Meta's published case concerns performance optimization in its Capacity Efficiency organization. MCP tools provide profiling, experiment results, configuration history, and code search. Skills hold expertise for specific codebases, languages, and problem types. Optimization and regression response reuse the same tools.
flowchart TD
O["Performance optimization and regression investigation"] --> S["Domain skills<br/>Codebase, language, problem type"]
S --> M["Common MCP tools"]
M --> D["Profiles, experiments, configuration history<br/>Code and documentation search"]
D --> C["Cause analysis and candidate fixes"]
C --> V["Candidate validation"]
V -->|Regression response| H["Regression-fix PR<br/>Review by author of the causal change"]
V -->|Optimization| E["Present validated candidates<br/>in the engineer's editor"]
Optimization candidates are checked for syntax, style, and fit to the problem, then presented in the engineer's editor. Regression-fix PRs request review from the engineer who authored the causal change. The source does not describe automatic merging, production deployment, or company-wide IAM implementation.
This case shows how a specialist organization builds workflows on common tools. It does not establish identical instruction distribution, permission inheritance, or version promotion across all Meta development teams. Meta Capacity Efficiency case, 2026-04-16
Google's code migrations and code-owner review
Google published an internal tool built by Core Developer, Ads, and DeepMind, including an Ads migration of IDs from 32 to 64 bits. Experts identify targets using Code Search, Kythe, and scripts. The tool expands the set of related files, and Gemini, fine-tuned on internal code, generates candidate edits.
flowchart TD
E["Experts identify targets<br/>Code Search, Kythe, scripts"] --> F["Expand related files"]
F --> G["Gemini and multiple prompts<br/>Generate candidates in parallel"]
G --> V["Compilation and unit tests<br/>Evaluate and select candidates"]
V -.->|Attempt repairs if needed| G
V --> H["Engineer inspection and edits"]
H --> R["Split changes<br/>Review by affected code owners"]
Multiple prompts generate candidates in parallel, and compilation and unit tests evaluate them to select changes. The model attempts repairs when needed. Engineers inspect and edit the results, then split changes for review by affected code owners. Initial target discovery and expansion did not use AI at that time.
Domain experts, repository verification, and review remain part of large migrations. This source describes migration work at the time. It does not establish current general-purpose coding harnesses or company-wide MCP Gateway operations. Google Research code migrations, 2024-07-18
Microsoft's risk-based management and central support
Microsoft Digital's internal account distinguishes personal, team, and enterprise-service agents. It assesses data access together with actions: low-risk reads can use self-service, while changes to organizational systems require more development and security review.
Team agents need ownership and lifecycle management. This is internal agent governance broader than coding harnesses. Microsoft internal governance, 2026-05-21
flowchart TD
A["Agent proposal"] --> R{"Sharing scope and data<br/>Assess reads, writes, and actions"}
R -->|Low risk| S["Self-service path"]
R -->|Enterprise functions or high impact| V["Development and security review"]
S --> O["Ownership and lifecycle management"]
V --> O
O --> I["Agent 365<br/>Inventory and governance status"]
C["AI CoE<br/>Common standards and execution coordination"] --> O
The AI CoE expanded beyond training and advice to set priorities, establish common standards, and coordinate execution. This aimed to reduce duplicate investment and inconsistent standards. Microsoft explicitly says it uses Agent 365 internally to view agent inventories, owners, lifecycles, and governance status across platforms. Microsoft AI CoE, 2026-04-16
Its MCP account covers server registration, ownership, review, and short-lived, scoped tokens. It also covers authentication, authorization, and auditing through an API Gateway.
Gateway placement is also described as a recommendation and end-to-end logging as a development goal. Automatic blocking of unregistered servers is an ideal state. These are not proof that all unapproved calls are already blocked and audited company-wide. Microsoft MCP security and governance
| Company | Shared operating unit | Team or task responsibility | Scope of the source |
|---|---|---|---|
| Uber | Wrapper, Registry, Gateway | Service tool review and skill authoring | Internal developer platform |
| BlackRock | Git-managed bread-kit | Team and repository knowledge | Customer account published by a vendor |
| Stripe | Blueprint, Toolshed, devbox | Task context and code review | Internal Minions tasks |
| Spotify | Fleet workflows, shared execution and tracing | Repository verification criteria | Honk and later development environments |
| Block | Shared check execution and skill distribution | Module checks and approval | Developer and cloud review workflows |
| Meta | Common tools and data access | Performance optimization domain skills | Capacity Efficiency organization |
| Migration generation and evaluation procedures | Expert scope selection and code review | Migrations published in 2024 | |
| Microsoft | Risk-based policies and central support | Agent ownership and lifecycle | Internal governance broader than coding |
LG CNS's development knowledge and financial project
Agentic AIND, published in June 2026, organizes development standards, security rules, source code, and artifacts into a Knowledge Foundation. Analysis, design, coding, and testing agents divide responsibilities. They implement and verify defined specifications, with human review and approval.
flowchart TD
K["Development standards and security rules<br/>Source code and artifacts"] --> F["Knowledge Foundation"]
F --> S["Analysis and design<br/>Define specifications"]
S --> C["Coding agent<br/>Implement specifications"]
C --> T["Testing and quality verification"]
T --> H["Human review and approval"]
P["Published application<br/>Financial company COBOL-to-Java conversion"] -.-> C
LG CNS says it is applying COBOL-to-Java conversion capabilities to a next-generation project at a large Korean financial company. This does not mean deployment to every customer. The source does not establish team policy inheritance, skill distribution, MCP permissions, update validation, or version promotion implementation. LG CNS announcement, 2026-06-08
Samsung SDS's coding assistance and AI Crews
Samsung SDS describes adopting IDE-integrated AI Pro and using CodeBot for coding assistance and reviews during its AI rollout in 2024. In 2025, at least one AI Crew member per team and a central organization connected local use-case discovery and adoption with governance.
flowchart TD
C["Central organization"] --> T["Team AI Crews<br/>Discover and share use cases"]
T --> U["Developers"]
A["AI Pro<br/>IDE coding assistance"] --> U
B["CodeBot<br/>Quality checks and reviews"] --> U
U -.->|Pilots and expansion preparation| F["Plan, generate, review, verify"]
P["MCP and internal permissions<br/>Under development at the time"] -.-> F
The same source describes agents connecting planning, generation, review, verification, and system changes as being prepared or built. MCP and internal permission integration were also under development. It publishes pilot results but says operational adoption needs further security and CX review. Tool use and adoption structures are documented, but a completed company-wide agent control architecture is not established. Samsung SDS AI Journey, 2025-10-24
NAVER's team assets and Context Provider
NAVER D2's June 2026 source presents the Place AI recommendation organization's experience building a Context Provider. The platform automatically collects team assets from data and serving layers to supply context to people and AI agents.
flowchart TD
D["Place AI recommendation organization<br/>Data and serving-layer assets"] --> C["Automatic team asset collection"]
C --> P["Context Provider"]
P --> H["Work context for people"]
P --> A["Work context for AI agents"]
The verified scope covers the presentation description, the team's affiliation, and its application topic. This is not an analysis of the video's detailed implementation. It cannot establish MCP, IAM, or deployment architecture, or company-wide coding harness operations at NAVER. NAVER D2 presentation, 2026-06-22
Toss's experiment sharing and MCP for external developers
AI Surf Day shared experiments through 142 Evangelists across subsidiaries and teams and about 200 Clubs at the start. These are people and organization counts, not harness deployments. A Codex workflow combined implementation, builds, iOS Simulator interaction, edits, and video inspection. It was a hackathon winner, not evidence of the entire daily development process. Toss AI Surf Day, 2026-06-05
flowchart TD
subgraph INTERNAL["Internal experiment sharing"]
direction TB
E["Evangelists and Clubs"] --> S["AI Surf Day<br/>Share experiments and hackathon cases"]
end
subgraph EXTERNAL["Support for external merchant developers"]
direction TB
D["MDX documentation"] --> C["CDN deployment through CI/CD"]
C --> M["Payments MCP<br/>npm and local STDIO"]
M --> A["Merchant developers' AI tools"]
end
Payments MCP is a knowledge tool that helps external merchant developers integrate payments. It follows document versions through the existing MDX-to-CDN CI/CD pipeline and distributes a local STDIO server through npm. This documents management of both source knowledge and its delivery path. Payments MCP implementation, 2025-06-24
The two sources cover internal experiment sharing and external developer support respectively. They do not establish a harness applying the same skills, policies, and permissions to every internal Toss development team.
| Company | Published scope | What the source alone does not establish |
|---|---|---|
| LG CNS | Structured development knowledge, role-specific tasks, application to a financial project | Team policy inheritance, MCP permissions, version promotion implementation |
| Samsung SDS | Coding assistance tools and team adoption structure | A completed company-wide coding-agent control architecture |
| NAVER | One team's experience collecting assets and building a Context Provider | Deployment and permission management of a company-wide coding harness |
| Toss | AI experiment sharing across the group and Payments MCP for external developers | A common harness operating across all internal development teams |
Dividing responsibility when applying the cases
The following sections propose designs drawn from these cases. Companies published different scopes at different times; no single company should be assumed to implement the entire structure. Shared operations and ownership of business knowledge can be divided as follows.
| Scope | Owner | Responsibilities | Permitted adjustments |
|---|---|---|---|
| Company | Developer platform team | Supported clients, installation and deployment, common skills, evaluation tools, observability | Additions through approved extension methods |
| Security and identity | Security, IAM, and data owners | User and task identities, data and external communication access, credentials, required restrictions | Changes through defined exception procedures |
| Business unit and domain | Domain platform and service owners | Business terminology, API and data contracts, architecture, domain skills | Managed by the owners of that area |
| Development team | Team lead and responsible developers | Repeated tasks, team workflows, task-specific skills, evaluation cases | Improved and verified by the team |
| Repository and module | Code owners | AGENTS.md, builds, tests, local checks, change precautions | Reviewed and versioned with code |
| Individual | Developer | Language, output format, personal workflow preferences | Within common permissions and required checks |
Selecting a team's skill must not expand access permissions. Installing a reconciliation procedure, for example, must leave production ledger writes subject to a separate policy decision. Adding more specific knowledge and changing permissions require separate controls.
Team knowledge and result evaluation
Team packages need procedures for the work and criteria for evaluating results. For the same kind of code change, a payments team needs to check consistency of amounts and states. A web team needs to check actual screens and input behavior.
| Example team | Knowledge and skills to provide | Required tools | Result evaluation |
|---|---|---|---|
| Payments and reconciliation | Idempotency, ledger rules, reconciliation procedures, data change plans | Permitted test environments, authorized query APIs | Amount and state invariants, integration tests, change review |
| Web and app | Design system, accessibility, UI implementation and verification procedures | Browsers and simulators, test accounts | Actual screens and input behavior, relevant tests |
| Data platform | Schemas, lineage, pipeline change procedures | Metadata and lineage queries, approved data access | Schema contracts, data quality, checks of affected jobs |
| Infrastructure | Deployment standards, incident response, change impact analysis | Permitted observability and test environments | Plan review, policy checks, post-deployment verification |
Keep company AGENTS.md instructions short, with common working standards and guidance for finding needed documents. Select team, repository, and task details by scope to avoid filling context with irrelevant procedures. Products read instruction files differently, so verify actual loading after distribution.
flowchart TD
C["Short company instructions"] --> L["Select context needed for the task"]
T["Team and domain knowledge"] --> L
R["Repository and module instructions"] --> L
S["Skills for this task"] --> L
L --> A["Agent task"]
P["User and task permission decision"] -->|Permitted tool access| A
A --> V["Repository verification and review"]
This diagram proposes how to select context. It does not define a product rule for merging company, team, and individual settings in the same top-down order. Separate instruction distribution from access decisions so selected skills cannot change permission policies.
Approved distribution and execution paths
Assign owners and change histories to common policies, team skills, and repository instructions. Combinations that pass review and task evaluation become approved releases. A catalog routes them to distribution paths for each product, OS, and execution environment.
flowchart TD
P["Common policies, team skills, repository instructions<br/>Owners and Git history"] --> V["Change review and compatibility checks<br/>Representative team task evaluation"]
V --> C["Approved releases and plugin catalog"]
C --> D["Distribution by product, OS, and execution environment"]
D --> A["Developer machines and isolated execution environments"]
A --> L["Verify actual configuration and plugin loading"]
L --> R["Record applied versions and verification results"]
At runtime, connect company identity and groups with task permissions. Model connections follow a separate path from MCP tool calls. PRs, CI, and code-owner review govern the conditions for merging and deploying changes.
flowchart TD
D["Approved distribution and verified loading"] --> A["Managed coding clients"]
I["Company identity, groups, task identity"] --> A
A --> G["MCP Gateway"]
G --> S["Service permission checks"]
S --> R["Permitted data and APIs"]
A --> M["Permitted model connections<br/>Model Gateway if needed"]
A --> C["PR, CI, and code-owner review"]
A -.-> E["Execution, policy, and verification records"]
G -.-> E
C -.-> E
| Component | Responsibility | Boundary to check separately |
|---|---|---|
| Catalog | Identify approved servers, plugins, and versions | Listing does not grant installation or call permissions |
| Distribution system | Apply approved files, plugins, and settings | Actual product loading after file delivery |
| Client policy | Restrict product actions | Support by OS, app, and CLI, and local execution paths |
| MCP Gateway | Manage tool-call identity, permissions, and routing | Execution and communication that bypass the Gateway |
| Target system | Decide actual user and task access to resources | Permissions by resource and operation, and token audience |
| CI and source control | Enforce merge and deployment conditions | Required checks and code-owner approval |
Registering a server in the catalog does not grant permission to call it. Successful Gateway authentication still requires checking the resources permitted by the connected system. MCP security guidance prohibits accepting and forwarding tokens that were not issued for the target server. MCP security recommendations
Local files, shells, browsers, and model communication also have their own execution paths. Assuming that MCP Gateway logs capture every agent action leaves gaps in observability.
Product management capabilities and differences
Applying common policies across products requires checking what each setting means. Ordinary defaults, model instructions, and restrictions that users cannot change are different controls. The following capabilities were rechecked in official product documentation on October 3, 2026; they are not customer deployment outcomes.
| Product | Capabilities for common operations | Difference that is easy to miss |
|---|---|---|
| Codex | requirements.toml, organization policies, managed MCP and hooks, private plugin distribution | Defaults versus enforced restrictions, local policies versus workspace distribution |
| Claude Code | Managed settings, managed MCP and hooks, private marketplaces, required or blocked plugins, version conditions | Managed source precedence and merging, plugin loading time, OS isolation |
| GitHub Copilot | Enterprise managed settings, permitted team overrides, plugin and MCP policies | The same key has different support across CLI, IDE, app, and cloud |
| Cursor | Team Rules, managed settings and hooks, team marketplaces, organization groups | Instructions versus execution controls, group combination, required versus optional installation |
Codex requirements and plugin distribution
Distinguish ordinary defaults in config.toml from enforced requirements in requirements.toml. Requirements restrict supported approval, isolation, MCP, hooks, and marketplace sources. Managed hook scripts need separate file distribution. The command network proxy does not cover all MCP, app, and web-search communication. Codex managed configuration
A workspace can import and synchronize plugins from private GitHub marketplaces and set installation policies by role. This is separate from local marketplace source restrictions. Importing a plugin grants neither app access nor user authentication. Imported plugins containing MCP are Desktop-only, so app, CLI, IDE, and cloud distribution cannot be treated as equivalent. Codex plugin management
Claude Code policy sources and loading time
Managed settings take precedence over user and project settings. Multiple managed sources select the priority source by default, with a separate merge option. Device MDM and file policies do not reach Anthropic-hosted sessions; consider server-managed policies for that environment. Managed hooks and minimum and maximum version conditions also belong to this settings scope. Claude settings deployment
Managed enabledPlugins can require or block plugin activation; marketplace registration and permitted sources are managed separately. Private repositories need read access for each user. Background installation may miss the first request, so verify when plugins load. Marketplace restrictions alone do not cover every other loading path, including skills and MCP. Claude plugin management
Copilot team settings and MCP restrictions
Teams can refine settings where enterprise policy allows overrides. Managed MCP allow and deny controls support CLI, VS Code, the Copilot app, and JetBrains, but not the cloud agent. Use the support table for each key to determine deployment targets. Copilot managed settings support, Copilot team settings
The private MCP registry is in public preview and uses name- and ID-based restrictions. GitHub states that users can bypass these restrictions by editing configuration and recommends the managed-settings MCP allowlist. Hiding servers from a list and restricting actual calls are different management capabilities. GitHub MCP management
Cursor instructions and installation policies
Team Rules supply team instructions to the model, while MCP command and URL allowlists restrict permitted servers. An allowlist entry does not deploy a server installation. Verify distribution and access restrictions separately. Cursor integration management
Team marketplaces distinguish Default Off, Default On, and Required installations. Users cannot remove Required plugins, but MCP provider authentication is still needed separately. Cursor plugins
Organization group settings do not always combine into the stricter value. Some settings combine model access as a union, spending limits as the higher value, and auto-run as the more permissive value. Test the actual group combinations. Cursor organization groups
Failure behavior and execution environments
A hook error does not always stop execution. Claude and Copilot may continue after some hook timeouts or communication failures. Cursor security hooks also need failClosed configuration and failure tests, so check failures alongside successful responses. Claude hooks, Copilot hooks, Cursor hooks
OS differences also matter. Claude's Bash sandbox does not support native Windows. Product and OS combinations that cannot enforce required restrictions must be excluded or confined to an environment that can. Claude sandbox
Product adapters need both configuration translation and tests of the resulting behavior. Explicitly marking unsupported requirements reduces the risk of mistaking a substitute setting for the requested control. After version changes, verify that the same setting keys still produce the same behavior.
Separating team packages from permission changes
Team-managed packages can record their scope, owner, required tools, and verification methods. The example shows management fields, not an actual Codex or Claude configuration schema.
id: payments-reconciliation
owner: payments-platform
version: 1.4.0
scope:
repositories: [payments-ledger]
context:
instructions: instructions.md
skills: [reconcile-in-test]
requires:
tools: [ledger-test-read, reconciliation-test-run]
verification:
checks: [ledger-invariants, reconciliation-integration]requires declares the tools needed; it does not grant permissions. Access must depend on authenticated user and task identities and service policies. Changing a team name in a local file must not expand access.
| Change | Reviewer | What to verify |
|---|---|---|
| Team documentation and code explanations | Team and repository owners | Accuracy and applicable location |
| Repeated-task skills | Team owner | Results and scope on representative tasks |
| Executable scripts and hooks | Platform owner, with security review when needed | Execution permissions, input handling, error and timeout behavior |
| MCP tools and descriptions | Service owner | Permissions, input and output contracts, exposed data, effects on existing tasks |
| Expanded production writes or external transfers | Security, data, and service owners | Approved scope, identity, auditing, and revocation |
| Common clients and models | Platform owner and participating teams | Product compatibility, actual task quality, restriction bypasses |
Central approval for every sentence edit slows improvement. Changes containing executable code or permission updates need review by the owners of affected systems. Routing reviews by change type preserves team autonomy alongside common controls.
Connect verification results to each package's owner, version, scope, required tools, and permissions. Reevaluate a skill on the new teams' representative tasks before expanding it beyond the team that passed. Effective instructions for one model do not establish the same effect for another model.
flowchart TD
S["Team skill change"] --> T["Evaluate representative tasks for the team and model"]
T --> L["Deploy within verified scope"]
L --> E{"Expand to more teams or models"}
E -->|Yes| N["Independent evaluation on new teams and models"]
N --> Q{"Results, scope, and controls meet criteria"}
Q -->|Yes| R["Approved release for expanded scope"]
Q -->|No| H["Keep existing verified scope and revise"]
E -->|No| K["Observe results within current scope"]
Evaluating updates against actual tasks
Evaluation needs a more specific target than a product name. Record the client version, OS, execution environment, model, common policies, team package, and tool contracts together. Treat a product's CLI and app, or native Windows and WSL2, as separate combinations.
Uber's uReview evaluates precision, recall, and F1 with human-labeled data and expanded incrementally by team and review function. It also incorporates user feedback into evaluation. That case can inform an update procedure such as the following. Uber uReview
Install candidate versions in a validation environment separate from operational settings. First check setting-key, plugin, and hook compatibility. Then run realistic tasks such as payments reconciliation edits or data schema changes. After validation, roll out to selected teams first to check for regressions in actual use.
flowchart TD
N["Separate validation environment<br/>Install candidate version"] --> P["Check configuration and plugin loading"]
P --> T["Test team tasks and prohibited actions"]
T --> F["Test communication, authentication, and hook failures"]
F --> Q{"Promotion criteria met"}
Q -->|Yes| C["Roll out to selected teams first"]
C --> O["Check task results and regressions"]
O --> S["Expand as an approved release"]
Q -->|No| H["Fix cause or hold candidate"]
O -->|Regression found| R["Revert to a compatible<br/>previous approved state"]
Configuration-file inspection alone cannot establish actual behavior. Test successful permitted tasks alongside rejection of prohibited tasks. The following regression checks should be adapted to the organization's requirements.
| Check | Question |
|---|---|
| Common instruction loading | Did the approved version enter the session? |
| Missing plugins or skills | Are missing required packages detected, with work stopping in the specified way? |
| Permitted tasks | Can the agent complete representative tasks using the required documents and tools? |
| Prohibited tasks | Are unauthorized file, tool, and network access denied? |
| Gateway disconnection or policy server error | Do required restrictions hold, or does work stop in the specified way? |
| Expired authentication | Does execution require reauthentication or stop, instead of using expired credentials? |
| Hook errors and timeouts | Does failure behavior match the designed policy? |
| Existing sessions | Was immediate policy application or the need to restart verified? |
| Result quality | Are review effort, corrections, rework, and defects increasing? |
Record rollback procedures separately for policies, team packages, and clients. Each needs its previous approved version, rollback scope, tool contracts that must remain compatible, and reverification method. Changing unrelated components together after a failure makes its cause and recovery harder to assess.
Pinning an old version cannot maintain service and model compatibility indefinitely. Codex app auto-update controls cover the app itself; they do not guarantee external deployment or service compatibility. Cursor also has a vendor minimum-version policy, so verify compatibility of the previous approved state. Codex update management, Cursor deployment management
Execution records and audit scope
Task records should identify which policies and tools were used for a change. Connect client execution records, Gateway permission decisions, and CI verification results through session and task identifiers. Recording an event and proving that required restrictions were enforced are separate things.
flowchart TD
T["Session and task identifiers"] --> C["Client<br/>Loaded versions and execution paths"]
T --> G["Gateway and target systems<br/>Tool calls and permission decisions"]
T --> V["PR and CI<br/>Verification and review results"]
C --> R["Connect related records"]
G --> R
V --> R
R --> A["Owners assess causes and impact"]
P["Collection scope, access permissions, retention"] -.-> R
| Record | What to establish |
|---|---|
| Session and task identifiers | Which request and change produced the execution? |
| Product, execution environment, and model | Which client version and environment ran the task? |
| Policy and team package versions | Which approved components actually loaded? |
| Tools called and results | Which tools were used, and did they succeed or fail? |
| Permission decisions | Which policies allowed or denied which user and task identities? |
| Verification and review results | Which checks passed, and who reviewed the change? |
Central collection of complete conversations and source code needs separate decisions on data scope, access, and retention. Ordinary operations can start with needed identifiers, versions, decisions, and results. Where content storage is needed, define its scope for that purpose. Local shell, file, and browser actions need explicit observation coverage; Gateway records alone cannot establish those actions.
Metrics for operational results
| Measurement | Question |
|---|---|
| Applied configuration | Did approved instructions, skills, and policies actually load into the session? |
| Access controls | Were prohibited actions actually blocked? |
| Task success | Did the requested change pass verification and meet business requirements? |
| Human effort | Did review, correction, and rework time decrease? |
| Operational quality | Did incidents, defects, reverts, or scope drift increase? |
| Update stability | Does the new version preserve team workflows and required controls? |
| Knowledge management | Are document and skill owners and verification status clear? |
Installation rates and generated-code volume alone do not establish performance. Observe review time, rework, change failures, and recovery too.
Summary
The published cases connect team and repository knowledge and checks to shared execution and deployment infrastructure. Applying this approach requires separate checks for instruction loading, actual permission decisions, and result verification. Product-specific configuration precedence and failure behavior also belong in the operating contract.
A small rollout can start with one team's representative task and complete verification. Adding another team means connecting its business knowledge and checks while verifying that common controls still hold. Updates can then expand from combinations that pass the same task and prohibited-action checks.