Goldman Sachs plans to remove Claude Code from the workflows of bankers and traders. The issue goes beyond coding productivity: it concerns what an Agent can access, what it can do, and who is accountable when something goes wrong.
Goldman Sachs Pulls Claude Code: Governing Agent Access
According to The State of AI, Goldman Sachs plans to remove Anthropic's Claude Code from the workflows of bankers and traders. The story reached the Hacker News front page, earning 220 points and 142 comments.
At first glance, this looks like a routine enterprise tooling story. In practice, it is a debate over Agent access governance: which repositories a development tool can read, which systems it can call, which data it can modify, and who is responsible when it fails.
Original report: https://www.thestateofai.com/news/goldman-sachs-claude-code-traders-bankers
Hacker News discussion: https://news.ycombinator.com/item?id=50415628
Goldman Sachs Removes Claude Code: What Happened
The State of AI reports that Goldman Sachs plans to remove Anthropic's Claude Code from the workflows of bankers and traders. Rather than focusing on whether the model can generate code faster, the report examines the actions Claude Code can take as an Agent.
The story reached the Hacker News front page, earning 220 points and 142 comments. The discussion centers on whether a general-purpose coding Agent should inherit employees' permissions inside a bank's internal systems and directly operate code, commands, and services.
Removing a tool is not the same as banning a model. Goldman Sachs may still use Claude, GPT, or other models for retrieval, summarization, and analysis. The difference is that a model offering recommendations and a model acting on behalf of an employee create two very different risk profiles.
A chat-based Copilot will generally display code on the screen. Tools such as Claude Code can read project files, run shell commands, modify code, and sometimes connect to external services. If a prompt is poisoned, the tool calls can follow it.
Goldman Sachs may therefore be pulling back not from Claude itself, but from a style of Agent use that lacks fine-grained permission boundaries.
The Real Problem Is Not Slow Coding
Code-generation speed matters, but regulated organizations measure a different set of concerns: data isolation, separation of duties, operational traceability, change approval, and incident response.
Suppose Claude Code is connected to a trader's workspace. It could see:
- Strategy code and backtesting projects
- Customer or order data
- Access tokens for internal APIs
- Deployment, monitoring, and alerting systems
- Scripts capable of moving real funds
An Agent can do more than misread a line of code. It could write sensitive information into logs, delete files, or change critical configuration based on faulty advice. More problematically, conventional access controls struggle to distinguish between an action performed directly by an employee and one performed by an Agent following that employee's instructions.
A Copilot's mistakes usually stop at the recommendation stage. A developer copies, reviews, and runs the output. An Agent can turn a recommendation directly into an action, removing the natural human checkpoint in between.
This is why banks cannot simply apply ordinary SaaS access-management practices to Agents. Treating an Agent like a standard employee account often gives it overly broad permissions: access to entire repositories, multiple environments, and deployment commands. If an account is exploited through prompt injection, the impact scales with its permissions rather than the model's capabilities.
What regulated organizations really care about is not how quickly Claude Code writes code. They need answers to three questions:
- What data can it access?
- What state can it change?
- Can the full sequence be reconstructed, with clear accountability, after an error?
Treat an Agent as a Service Account, Not an Employee
An Agent should neither inherit an employee's full access rights nor be treated as if it were a person. A more accurate model is a constrained, non-human service account.
A service account has a clear identity. The system should be able to show which identity runs the code, which resources it can read, which actions it can perform, and how data flows. It should use short-lived credentials, receive temporary authorization for each task, and lose access when the task ends.
This is not merely a semantic distinction. It directly changes how the system is built.
If an Agent inherits a banker's SSO permissions, every tool call may use the person's complete session. Audit logs will show only that “a banker performed an action.” It will be difficult to determine whether that step came from Claude Code's planning, an external web page, or a shell command assembled by the Agent itself.
With an independent identity, the logs can answer:
[09:31:04] agent=claude-code task=fix-trade-report
[09:31:07] granted read access to repo:risk-reporting
[09:31:11] denied write access to env:production
[09:31:14] proposed command: npm run test
[09:31:18] human approval requested
[09:31:22] human=trader_042 approved scoped test run
The person, task, credentials, commands, and approvals can all be correlated. In a regulated environment, that is far more useful than having a model response that sounds authoritative.
Short-lived credentials are equally important. An Agent's task typically lasts from tens of minutes to a few hours, so its credentials need not remain valid for weeks. They can be bound to a specific repository, environment, and action type, then actively revoked when the task ends.
Least privilege does not mean reducing permissions to the point of uselessness. It means separating permissions by action. Permission to read code does not imply permission to read .env; permission to run unit tests does not imply permission to run deployment scripts; permission to create a branch does not imply permission to merge into main.
A Practical Checklist for Financial-Grade Permission Isolation
The following checklist is intended for banks, brokerages, and other regulated teams.
1. Isolate the Execution Environment
Do not let Agents run by default on a trader's or banker's everyday device. At a minimum, execute code in an isolated container, virtual machine, or dedicated runner.
- Use temporary copies of workspaces
- Configure mounted directories with a task-specific allowlist
- Block access to host sockets, the Docker socket, and personal directories by default
- Set CPU, memory, runtime, and disk quotas
- Destroy temporary environments when the task ends
A container is not the entire security boundary, but it is easier to control than running scripts directly on an employee's terminal. In particular, do not mount the Docker socket into a container for convenience.
2. Restrict External Connections
An Agent's ability to read documentation does not imply that it should be able to reach the open internet.
- Use a domain allowlist rather than configuring outbound ports alone
- Block cloud-provider metadata endpoints and internal administrative network ranges
- Inspect downloaded content for file type, size, and malicious payloads
- Treat web pages, issues, pull requests, and dependency packages as untrusted input
- Require policy checks before data leaves the environment or is sent externally
Prompt injection does not require an elaborate model-based attack. An instruction hidden in an issue, README, or web page can cause real damage simply by persuading an Agent to make the wrong tool call.
3. Require Confirmation for Sensitive Actions
Code review should not be the only barrier to production deployment. Accessing sensitive data, changing strategies, calling trading interfaces, and sending email should also be classified by risk.
One possible default policy is:
low risk: read current repository, run lint, run unit tests -> execute automatically
medium risk: create branch, commit code, modify CI -> show diff and confirm
high risk: access customer data, write to production, execute deployment or funds-related commands -> independent approval
The confirmation screen should not merely ask whether Claude is allowed to proceed. It should display the full command, target environment, data involved, change diff, and potential side effects.
4. Preserve Command and Data Access Logs
Logs must capture the full chain of activity, not just the conversation.
At minimum, retain:
- The user identity and Agent identity
- Task ID, model version, and tool version
- Every tool call and a summary of its parameters
- Data paths read, written, or deleted
- Shell commands, exit codes, and execution environments
- Human approvals, rejections, and the identity of the approver
- Secret references and usage records, without storing plaintext secrets
Logs should also resist arbitrary modification and have a sensible retention period. For external audits, knowing that an event occurred is only the first step. Proving that the record was not rewritten is the second.
5. Enforce Policy at the Execution Layer
Many teams give an Agent a system prompt such as “do not modify the production environment.” A prompt is not access control.
The correct approach is to enforce restrictions at the tool layer. Even if a model requests a high-risk command, the execution gateway should deny it. Even if a prompt is poisoned, the service account should still be unable to obtain production credentials.
One practical starting point is to divide tools into three tiers:
safe_read -> execute automatically and record
scoped_write -> execute after policy checks, requesting confirmation when needed
protected_ops -> deny by default; allow only specific roles or approval workflows
After a request passes policy checks, the tool layer issues credentials with a limited scope. The object being approved is then a concrete action, not a paragraph of natural language.
6. Establish Red-Team and Revocation Procedures
Before deployment, test several common scenarios:
- Malicious instructions hidden in a repository README
- An Agent attempting to read an unrelated directory
- A test script that includes calls to a production API
- Command contents changed after approval
- Credentials obtained for one task being reused in another
Each scenario should verify both that the request was denied and that the logs are complete. Teams also need one-click controls to disable tools, revoke credentials, and deactivate the Agent identity.
Editorial Perspective
The significance of Goldman Sachs removing Claude Code is not that it proves a particular model is unsuitable for finance. It shows that enterprise Agent governance is shifting from deciding what the system should recommend to defining what it is permitted to do. Copilot mainly generated text or code, leaving developers with a review step before execution. Agents work differently: they can read repositories, run commands, modify systems, and push errors directly into the execution chain.
Enterprises are unlikely to abandon Agents altogether. Instead, they will likely create narrower versions with fixed data sources, fixed tools, and fixed execution environments, then grant permissions incrementally. Claude Code may continue to support development, while trading, customer data, and production systems will rely on independent identities and short-lived credentials.
It remains unclear whether the reported removal will result in a full ban, restricted use, or a controlled pilot. Each interpretation will affect the scale of the required access-control redesign. One conclusion is already clear: the stronger the model, the less organizations can rely on prompts to enforce permissions.