Skip to content
Beta
All articles

Claude apps gateway: pooled budgets, layered policies and a cost report

Claude apps gateway changes this week: shared group budgets, stacking policies, spend by IdP group and per-developer AWS roles, and where to be careful.

By The SpanDock team

6 min read

A diagram of a developer request passing a stack of matching policies, then a personal spend cap and a shared group pool, before reaching a model upstream

Between 30 October and 4 November 2026, Anthropic shipped a run of admin changes to the Claude apps gateway, the self-hosted gateway that sits between Claude Code or Claude Desktop and your model providers. Groups can now share a monthly budget, several policies can apply to one developer at once, a cost report breaks spend down by identity-provider group, and more upstreams can bill AWS usage to the developer who made it. Each is useful. One of them, layered policies, can also quietly loosen your rules if you adopt it without reading the merge order.

What changed, release by release

All dates and versions below come from the Claude Code changelog, which covers the gateway too.

  • 2.1.314 (30 October): an optional groups list on an upstream, so only developers in the listed IdP groups are sent to it, including on failover. Bedrock upstreams gained guardrail_trace, which logs which Bedrock guardrail filter fired without the matched text.
  • 2.1.316 (31 October): pooled group budgets, described as "one monthly budget that a group's members share, on top of each member's own limit", set with pooled_budget on the spend limits admin API. Also managed.policy_mode: layered, and a fix so the gateway checks every model a request names against availableModels, deniedModels and models, returning a 400 that names the field.
  • 2.1.317 (3 November): a cost report at GET /v1/organizations/analytics/cost, reading past spend over a date range in total, per developer, per day or per IdP group, and a daily record of each developer's IdP groups, kept for admin.identity_retention_days. It also fixed the status line showing a developer's own limit as fully used after their group's pool ran out.
  • 2.1.318 (4 November): assume_role on mantle upstreams, for a role in another AWS account and per-developer AWS cost attribution.

Budgets: per-seat caps, and now a shared pool

The spend limits page explains the model that existed before this week. Caps are set per day, week or month for a user, an IdP group or the organisation, in whole US cents ("10000" is $100). A developer over any cap gets a 429 on the next request until the period resets or an admin raises it. Per period, the cap that applies is a per-user override first, then the most restrictive of the developer's group caps, then the organisation default, then unlimited.

The same page says plainly that "a group or organization cap is a per-seat default that each member inherits, not a shared pool". That was the limitation: a $100 group cap meant $100 each, not $100 between them. The 2.1.316 pool adds the missing piece, a monthly amount the whole group draws from while each member's own cap still applies.

Note a gap between sources. When we read it, the spend limits page did not yet document pooled_budget and still described group caps only as per-seat defaults. The changelog is the only source for the pool's existence and its monthly period. Until the reference catches up, test the request shape against your own gateway rather than guessing at it.

Reporting spend by group

The new cost report closes a common gap. Live caps tell you who is blocked; the report tells you where last month's money went, by person, by day or by IdP group. Because group membership changes, the gateway now records each developer's groups daily, so spend is attributed to the groups someone was in at the time. That record is identity data, kept for the retention you set, so decide that number deliberately.

Layered policies: more power, more ways to loosen rules

Until now, the gateway applied the first managed policy that matched a developer. With managed.policy_mode: layered, every matching policy applies, each merged over the ones listed below it. The configuration reference sets out the merge rules:

  • allow-lists, single values and blocks such as sandbox come whole from the first-listed matching policy that sets them;
  • deny-lists and hook arrays add up across policies;
  • env, modelOverrides and skillOverrides merge by name.

The reference also warns that policies can combine into a looser result than any one of them. Its example: a base policy for everyone turns the sandbox on, one group's policy allows Bash, and another group's policy turns the sandbox off. A developer in both groups can end up with Bash allowed and the sandbox off. The suggested fix is to list the policy that allows Bash first and copy the sandbox block into it, so it wins whole.

There are operational conditions too. Layered mode needs version 2.1.316 or later on the gateway, and an older gateway refuses to start with the key set, so upgrade every replica first and remove the key before any rollback. In layered mode the gateway also refuses to start if a Read or Edit deny or ask rule uses ! negation, or if disableAllHooks, allowedHttpHookUrls or httpHookAllowedEnvVars appear outside the policy that matches everyone.

Per-developer AWS roles

With assume_role, the gateway uses its own AWS identity only to call sts:AssumeRole, then calls the model with one-hour credentials for the role. Setting the session name per developer gives one session per developer, so AWS billing can show who spent what. The reference notes that if STS fails, the gateway does not fall back to its own credentials for that upstream; it tries the next upstream instead. That is the safe behaviour, but it means a broken trust policy looks like a failover, not an error, so alert on it.

What it means for engineering and security leaders

These changes move the gateway closer to a full cost and policy layer: caps, pools, reports and attribution in one place. The trade-off is that its behaviour now depends on combinations. A pool and a personal cap both apply. Several policies stack. An upstream may be reachable only by some groups. The question "what can this developer do, and what will it cost?" needs testing, not reading one file.

Also check the version spread. Several features need a minimum version on the gateway server itself: layered mode needs 2.1.316, and assume_role on mantle upstreams needs 2.1.318. The reference says an earlier gateway exits at startup when it meets a key it doesn't recognise, so a config change can turn into an outage on a replica you forgot.

Practical takeaways

  1. Model your pools before turning them on. For each group, write down the pool, the members' own caps and what happens when the pool runs out first.
  2. Review policy order before enabling layered mode. List the policies that set a sandbox, allow Bash or set model lists, and check the combined result for a developer in several groups.
  3. Upgrade every gateway replica before adding new keys, and keep a rollback plan that removes them.
  4. Set admin.identity_retention_days on purpose, since the daily group record is personal data.
  5. Alert on STS failures if you use assume_role, so a silent failover doesn't hide a misconfigured role.
  6. Rerun model allow-list tests. Since 2.1.316 the gateway checks every model a request names, so requests that used to pass may now get a 400.

If your developers use several AI tools, not only Claude's, SpanDock's model proxy keeps each person within a daily, weekly or monthly budget across them. Near the limit it uses only cheaper models, and over it the administrator chooses whether calls are blocked, sent to the cheapest model or just flagged. Per-person budgets are on the Standard plan and up. For background, see per-person budgets and SpanDock Mind.

Sources

  1. Claude Code changelog (versions 2.1.314 to 2.1.318)
  2. Claude apps gateway: configuration reference
  3. Claude apps gateway: spend limits
Cookie categories

Details: Cookie Policy.