🪪 Every Agent Gets Its Own Identity, Scoped to Its Team
📅 Monday, Nov 16, 2026
⏰ 9:00 AM
Every agent in a software factory needs to run under its own identity, scoped to what its team is already allowed to touch. Build each factory around a group’s existing delivery process and permissions. Across team lines, the agent uses only what the other team publishes: a public or internal contract that spells out which operations a consumer is allowed to call, the access scope each one requires, and what every response means. When the contract runs out, it asks the owner.
Say the Orders team needs to show whether a customer’s invoice has been paid. Billing owns that answer. It runs a monolith and publishes a versioned REST API that Orders can use. An Orders developer gets the API contract, sample responses, and a sandbox. Billing’s implementation repository can be invisible to Orders, including its name in repository listings and search.
Now put that ticket into a software factory. Before its agents read a line of code, I want to know whose authority each one is acting under. Give any of them a credential that can search every repository and you’ve overridden a decision the company made about who can read Billing’s code.
Separating context between teams (each team’s code, its documents, what its agents can search) might not seem like a big deal. If you’re a startup or a small company, there’s usually no separation to keep. Corporations keep it on purpose. In the enterprise, the factory needs to address it from the first ticket.
Start with the group’s existing SDLC
I argued in The Software Factory Was Already Here that a company should design the development lifecycle around its own product and people. In a large enterprise, that means I’d build each factory for the group that owns delivery. A shared platform can provide orchestration and audit logs for every group, with templates to start from. Orders can define a workflow around the repositories it can access, the contracts it can use, and its own review and release gates. Billing gets the same platform, with a workflow built around its own responsibilities and permissions.
Before designing either factory, I’d sit with the engineers who build and review the code and the operators who run it. Together we’d trace one real change through their current software development lifecycle (SDLC), from intake and design through build, testing, approval, deployment, and production support. DORA’s guide to value stream mapping describes the same walk and flags handoffs between teams as a frequent source of miscommunication and delay. At each handoff, identify which group owns the next decision, which repositories and environments it can access, and what evidence it needs to proceed. When the work crosses teams, find out what information can be shared and who accepts the handoff. That’s where I’d decide which steps the agents can complete after a coded check and which decisions belong with an accountable owner.
A startup or other small company may have one engineering group that can read every repository and follows a shared SDLC. If that group also runs every application, service, worker, and scheduled job the company deploys, I’d build one factory for it, starting from the source visibility and release controls the team already uses.
Give each agent an identity
When I say agents need agency, I mean each one can carry out a defined job under its own identity. A team owns the work, and the owners of the resources the agents use control what they grant. Each run records the acting identity, its authorized scope, and who or what started it. A developer can delegate work within the authority they’ve been granted; a scheduled run uses the permissions explicitly assigned to that workflow.
The Orders coding agent can read the Orders repository, push a working branch, and open a pull request. A review agent on the same platform is allowed to read the diff and post comments, and branch protection holds the merge until the team’s required checks pass and its required reviewers approve. To build the feature, the coding agent can fetch the Billing contract and exercise the documented read operation against synthetic invoices in a sandbox. In production, the deployed Orders service asks for invoice status under its own identity.
A workload identity identifies each agent’s running software to the systems it calls; authorization decides which repositories and environments that identity can reach and what it can do in each. GitHub Apps show how tight that can get. Once an app is installed on an organization’s repositories, its installation token expires after an hour and can be narrowed to selected repositories and permissions, never beyond what the installation was granted. Give the job its own workspace. Keep its credentials in the tools that execute the work. Source control and search enforce their own access rules, and so does the service receiving the call; under NIST’s zero trust architecture , nothing is trusted just because of where it sits on the network.
Publish the parts other teams need
An enterprise can give people and agents the same approved integration material. An API catalog advertises that an interface exists and which versions are supported; the contract tells consumers how to use it. For HTTP APIs, OpenAPI gives people and tools a machine-readable description of each operation and schema, including its security requirements.
| Where to look | What a consumer gets | Example |
|---|---|---|
| API catalog or registry | A searchable inventory of APIs with their versions, lifecycle stage, and definitions (the contracts), plus custom fields such as an owner | Azure API Center |
| Developer portal | Documentation on how to use an API, a console to try it, and a way to request access | Azure API Management developer portal |
| Software catalog | The team that owns a service, website, or library, and its published relationships to APIs and other components | Backstage component descriptor |
| Package registry or artifact repository | A versioned dependency the build can fetch, such as a Maven artifact or a native library distributed through a Conan remote | AWS CodeArtifact , Conan |
| API gateway | The route for live calls when deployed, with policies such as credential validation and rate limits. The service can still apply its own rules about which invoice a caller may read | Azure API Management gateway |
Several of those capabilities can live in one platform. Billing might publish a catalog entry that names the owning team and links the API contract, then grant call access to a smaller set of identities. An internal C library works the same way. Its catalog entry lists the version and the supported build targets, plus usage examples; the artifact repository delivers the matching headers and binaries to authorized builds. Source access stays with the owner.
Billing’s contract for GET /v1/invoices/{id}/status names the access scope it requires and what each response means. If Billing returns a temporary error, the Orders page should say payment status is unavailable; an unpaid invoice is a separate state, and Billing reports it explicitly. Billing can run consumer contract tests
on every change, replaying the requests Orders recorded and comparing each response with what Orders expects. Behind that contract, Billing can refactor its modules or move the service to a new deployment, and the contract doesn’t have to change
. Microservice or monolith, it’s the same pattern.
Give the agents the system context they can use
The Orders repository can show a generated client and the code that calls it. A system context diagram can show that Billing owns invoice status and which other systems depend on it, and a deployment diagram shows where that software runs on the infrastructure in a given environment. Integration docs can tell Orders which endpoint to use in the sandbox and which route reaches the production service. Put those views and the relevant architecture decisions where authorized consumers can find them, with an owner who can update them when the integration changes.
Search has to enforce the same boundaries as the material it indexes. Apply source permissions whenever the agents retrieve documents or code, before excerpts reach the model (Azure AI Search, for one, can trim results at query time to the documents the caller may read). An automatically generated summary of Billing’s private source belongs to the same audience as the source. Catalog metadata and cached results need access rules too , so each agent sees only the owners and dependencies it’s allowed to retrieve.
When the contract runs out, ask the owner
Suppose the ticket asks why an invoice is on hold, and the published API only gives a status. The agents can report exactly what they know: the contract available to Orders omits the reason. Billing may already record it internally. So the next step is to ask the owner. If Billing chooses to expose a reason code, its team (or its agents) can make that change under Billing’s own authority. Orders can then build against the updated contract.
That’s Conway’s Law at the scale of one change. Conway tied a system’s design to the communication paths of the organization that builds it. I wrote in Conway’s Law Meets the Corpus Effect about how models fill in the choices an organization leaves open. This time the organization has already made the choice. The Billing contract is the path for using an existing capability, and the handoff to its owner is the path for changing it.
The factory can follow both.
The first ticket is the acceptance test
I’d make the invoice-status ticket the first acceptance test for the Orders factory. Give it to the factory’s team of agents and see if they can open a passing pull request using the published contract, one small job at a time. The coding agent generates a client from the contract and writes the page change, with tests for paid and unpaid invoices and for a status Billing couldn’t return. A separate test agent runs that code against synthetic invoices in the sandbox, so the agent that wrote the change isn’t the one grading it. Then the review agent reads the diff and flags any call the contract doesn’t document. Each job has to pass its check before the next agent starts.
In the same run, verify for every agent that repository discovery shows only the authorized inventory, that Git and search both deny access to Billing’s source, and that the production access policy rejects the sandbox credential.
That’s what I want to see before I give the factory its second ticket.