Engineering note
Coding Agents: Why Does Permission to Fix Code Not Authorize Accounts and Network Access?
WIRED’s October 29, 2026 report cites anonymous allegations involving a personal coding agent. Accenture disputes them; DoD declined comment. Anthropic’s reported response points to usage policy, not incident confirmation. These accounts do not establish a verified data flow or responsibility.
Such a dispute raises a question that does not require deciding the case: when we let an agent fix code, what have we actually authorized? Reading a working directory, running tests, using an existing login, contacting an external service, and deploying to production may occur in sequence. They should not be collapsed into one ambiguous approval.
This article uses public documentation and a fictional scenario to examine that question. It does not reconstruct a real system or judge whether any named organization or individual acted improperly. The engineering task is to give each required permission a defined owner, execution context, and revocation path.
Start with a repair task containing no real credentials
The following is a fictional workflow created by Bloss0m. It does not represent the organizations, networks, or people in the report and contains no real accounts, credentials, or execution results.
A team wants an agent to fix a small report-export bug. The agent receives a de-identified code copy and synthetic test data. It may produce a patch and test it in an isolated environment. If a dependency is missing, it can propose a dependency request. Once tests pass, a separate controlled process reviews the patch and decides whether deployment should follow. The deliverable is an inspectable change with test evidence, rather than logging into every related system on someone’s behalf.
Suppose the developer machine also holds a cloud CLI login, browser sessions, a package-registry token, and access to a diagnostics website. Even without an instruction to read them, an executing process may inherit environment information or use available authentication resources. The designer must therefore ask not only whether the model would choose to use something, but whether the underlying system would allow an attempted use to succeed.
That is an analysis of possible capabilities, not a claim that a particular tool necessarily reads or exports credentials. Separating capability from observed behavior makes it possible to discuss testable restrictions instead of guessing the model’s intent.
One task instruction contains at least five separate decisions
The following is Bloss0m’s engineering synthesis for examining the fictional workflow. It is not a five-layer guarantee defined by a product or standard.
| Decision | Allowed scope in the fictional workflow | Authority that does not follow from it |
|---|---|---|
| Task objective | Fix the specified export bug and propose a patch | Expand the assignment or deploy to production |
| Tools and execution processes | Read and edit a bounded copy and run designated tests | Execute arbitrary programs or use all local resources |
| Identity and credentials | A separate limited identity when tests need one; none when they do not | Inherit the full privileges of a human administrator |
| Network and outbound data | Retrieve approved dependencies and send necessary content under policy | Upload arbitrary logs, source code, or diagnostic bundles |
| Evidence and subsequent actions | Preserve inspectable results and hand them to the next process | Treat a tool’s success response as completed security verification |
The table helps locate authority silently carried from one decision into another. Permission to read an error log does not authorize pasting the complete log into an external diagnostic service. Permission to run tests does not authorize those tests to use every cloud identity on the machine. Permission to generate a patch does not let the agent choose its own deployment account.
NIST’s SP 800-207, Zero Trust Architecture, published in 2020, focuses trust on resources and access decisions rather than granting it merely because an account is on an internal network or an asset belongs to the organization. Applied to agents, the engineering implication is that running inside a controlled network does not answer which identity may perform which action on a resource. This is not a forensic conclusion about the disputed report.
Permission prompts and sandboxes answer different questions
As read on November 2, 2026, the official Claude Code permissions documentation describes tool permissions and sandboxing as complementary layers. One governs allowed tools and actions; the other restricts the files and network reachable by executing processes. Prompts also depend on modes and rules. One screen’s approval behavior should not become a claim about all versions and tools.
In the fictional team, a prompt is useful for a concrete decision such as accepting a patch. It is a poor place to expect someone viewing a test command to mentally evaluate every dependency, subprocess, existing login, and remote API. Repeated prompts cannot replace a bounded execution environment.
The official sandbox documentation specifically scopes the shell sandbox to shell commands and their child processes. Other file tools, MCP servers, and hooks are outside that same boundary. Credentials, files, and network access also have separate configuration. “Sandbox enabled” therefore needs follow-up questions: which process, which resource, and which exceptions? It does not establish isolation across every channel an agent uses.
Bloss0m’s design recommendation is to make fixed, lower-risk actions subject to repeatable enforcement, while reserving human judgment for meaningful deliverables and changes in authority. If a dependency is missing, the agent should submit a specific request. A failed test should not quietly widen execution privileges, expose more credentials, or open the entire network. This is a workflow recommendation, rather than a tested configuration that prevents every attack.
An allowed destination does not specify an allowed payload
In the fictional workflow, a package mirror, code host, and diagnostic service each have plausible uses. But an allowlisted destination answers only part of the connection question. Payload content, the remote account’s privileges, service retention, and whether returned content can influence subsequent actions remain separate decisions.
For example, downloading an approved package and uploading a full test log may involve the same service ecosystem while creating different data risks. Even without passwords, logs may contain internal paths, customer identifiers, environment variables, or system structure. In this fictional scenario, a safer next step is to create an inspectable, reduced diagnostic bundle and, where necessary, have a separate process transmit it. Connectivity should not be treated as permission to send everything.
External documentation, package descriptions, and service responses may also contain instruction-like text. Claude Code’s official security documentation identifies prompt injection as a risk and describes permission and isolation measures. This supports treating external content as data rather than automatically letting it change the task or request credentials. It neither establishes prompt injection as the cause of the reported dispute nor guarantees that a product has eliminated the risk.
Identity introduces another distinction. An agent service account, a developer’s account, and a model-service subscription are different authorizations. Legitimate access to a model service does not itself authorize sending another organization’s information to it. Conversely, organizational approval of a model service does not mean every workload may use administrator credentials.
Audit authority changes, rather than retaining chat alone
For the fictional team, useful evidence should answer which task produced a patch, where tests ran, which identity was used, which destinations received requests, which actions were refused or escalated, who accepted the changes, and who authorized deployment.
This is Bloss0m’s audit-design recommendation, not a statement that any one product currently records all those facts. Chat alone can miss subprocess and server-side actions. Network records alone may not identify the task behind a connection. Correlatable work and action identifiers are needed to connect provenance, execution, and acceptance decisions. Logs should also redact secrets: improving traceability should not create another full copy of a credential.
If a test shows an attempted unapproved connection, the first questions should be which layer blocked it, whether the identity remains valid, and whether the environment has other available channels. An agent’s verbal acknowledgment is insufficient. Stopping work, revoking identity, and preserving evidence should be handled by operational controls. This remains a conceptual scenario, not a claim that these steps occurred in any named case.
A bounded check teams can perform is to take a synthetic task with no real secrets and mark each authority transition between reading a copy, running tests, retrieving dependencies, submitting a patch, and authorizing deployment. At each transition, identify who can actually prevent the next step after refusal. Product adoption should rest on those inspectable conditions and the organization’s data policy, rather than speculation about a disputed report or an agent’s apparent ability to finish work smoothly.