Implementation Guide

    Mapping Anthropic Workspaces, AWS Accounts, and GCP Projects to One Team Policy Model

    Treat the team as the unit of policy. Define a short set of team attributes (permitted models, data classes, tool access, approval requirements, rate limits, owner), assign every Anthropic workspace, AWS account and GCP project to exactly one team, and use each provider's native boundary for identity, credentials and quota. Enforce the shared attributes at runtime in the execution path, so the same rule applies on every route to Claude and produces the same evidence.

    Evaluation checklist for your mapping

    • Can you state, for any team, which models and data classes are permitted on every route?
    • Does every workspace, account and project have exactly one owning team identifier?
    • Is each team attribute marked as natively enforced or runtime enforced, per provider?
    • Are native quotas and spend limits set per construct from the team record?
    • Does one evidence format show the same rule applied across all three routes?
    • Is there a named approver for exceptions, with approvals recorded consistently?

    Start with the team, not the provider

    A team that reaches Claude through the Anthropic API, Amazon Bedrock and Google Vertex AI is working inside three organizational constructs: an Anthropic workspace, an AWS account and a GCP project. Each has its own identity model, permission model and quota model. If policy is written per construct, the same team can end up with different permissions, data-handling rules and approval steps depending on the route it happens to use.

    The fix is to invert the design. Write the policy once, against the team, and treat each provider construct as a container that carries that policy. This follows the shape of the dynamic-policy model in NIST SP 800-207, where access is decided from the observable state of the client identity, the application or service and the requesting asset, plus other attributes. The decision model does not depend on which provider carries the request.

    This matters beyond tidiness. NIST AI RMF GOVERN 6 expects policies and procedures that address risks arising from third-party software, data and supply chain issues. A team consuming one model through several providers is exactly where that expectation becomes hard to demonstrate without a shared policy.

    The constructs side by side

    The three constructs play the same role in the mapping even though their mechanics differ. Each one scopes who can call the model, which credentials are in use, how much usage is allowed and where usage is reported. The table states what each contributes to the team model.

    • Team policy record: The source of truth. Names the owning team, permitted models, data classes, tool access, approval requirements and rate limits. Provider-neutral.
    • Anthropic workspace: Container for API keys, usage and spend limits inside the Anthropic organization. Map one workspace to one team and one environment.
    • AWS account: Permission, quota and billing boundary for Bedrock access. Map one account, or a defined set of accounts, to one team and place it in an organizational unit that reflects ownership.
    • GCP project: Permission, quota and billing boundary for Vertex AI access. Map one project to one team and environment, grouped under folders that reflect ownership.

    Reference mapping pattern

    The pattern below works whether you are starting fresh or retrofitting existing accounts, projects and workspaces. The key constraint is a many-to-one rule: a provider construct belongs to exactly one team, while a team may own several constructs. A construct shared by two teams cannot carry either team's policy cleanly.

    Keep the team identifier identical in every provider, for example as a naming convention and a tag or label. That identifier is what lets a single policy decision and a single evidence record refer to the same team regardless of route.

    • Define the team record: owner, permitted models, data classes, tool access, approval requirements, rate limits.
    • Assign each Anthropic workspace, AWS account and GCP project to one team and one environment, using a shared team identifier.
    • Scope credentials and roles inside each construct to the team's identities, and remove broad shared keys.
    • Set native quotas and spend limits per construct as the outer boundary, derived from the team record.
    • Route production traffic through one enforcement point that reads the team record.
    • Deny direct access outside that path where the provider allows it.

    Where native controls end and runtime policy begins

    Native provider controls are strongest at the boundary. They decide who can authenticate, which credential is valid, which resource owner is billed and how much usage is allowed. Those are the right tools for the outer limit of a team's access, and the mapping above relies on them.

    Team policy attributes that apply per request are different. Examples are which data class a prompt contains, whether a sensitive value must be redacted before it reaches the model, whether a specific tool call needs a human to approve it, and whether the same rule produced the same outcome on all three routes. Each provider expresses these differently, if it expresses them at all. For each attribute in the team record, decide whether all three constructs can enforce it equivalently. If they cannot, the attribute needs enforcement outside the provider, in the request path.

    The evidence problem follows the same line. Each provider records activity in its own structure and vocabulary, scoped to its own construct. An auditor asking who was permitted to use which model, and which controls applied, would have to reconcile three formats and infer that the rule was the same. A shared policy needs a shared evidence record.

    Enforcing the shared policy in the execution path

    Runtime enforcement means the policy decision is made on the interaction itself, before it completes, and not reviewed after the fact. Trussed enforces policy in the execution path across models, agents, tools and MCP servers. For each individual interaction or tool call it can allow, redact, block, rate limit or escalate for human approval, using the team attributes as the decision input. Scope matters here: enforcement applies to individual interactions and tool calls.

    Because each decision is made against the same team record, the outcome and the evidence have the same shape whether the request travelled to the Anthropic API, Bedrock or Vertex AI. Trussed generates audit-ready evidence from enforcement and maps it to frameworks including NIST and the EU AI Act. Deployment is self-managed in the customer cloud, with configurable retention and data residency.

    There are tradeoffs to plan for. An enforcement point in the path becomes a component you operate and size, and its policy needs an owner and a change process. It only produces consistent evidence for traffic that passes through it, which is why the mapping pattern pairs it with native controls that restrict direct access. Exception handling also needs a defined approver per team so that approvals are recorded the same way everywhere.

    One team policy, three provider boundaries

    Team policy record

    Owner, permitted models, data classes, tool access, approval rules, rate limits.

    Provider boundary

    Anthropic workspace, AWS account or GCP project assigned to one team.

    Runtime enforcement

    Allow, redact, block, rate limit or escalate per interaction and tool call.

    Audit-ready evidence

    One record format showing which rule applied, on any route.

    Apply one team policy across every route to Claude

    Talk through your workspace, account and project layout and see how policy enforced in the execution path produces consistent, audit-ready evidence.

    Talk to an Expert