Identity is not only an access concern. It is a runtime baseline.
A system becomes harder to govern when it cannot reliably say who or what is acting. Policy, telemetry, routing constraints, and audit logic all depend on that answer being stable. If runtime identity is vague, downstream controls weaken. The problem is not only security failure. It is operational ambiguity.
This matters because modern systems do not act through users alone. Work moves through services, workloads, jobs, pipelines, brokers, agents, and tool chains. A user may initiate a request, but the meaningful action often happens several handoffs later. If identity does not survive those handoffs with enough precision, the platform loses the ability to bind control and evidence to the same actor.
That is where many systems become misleading. They appear instrumented and governed, but their actor model is too coarse to support either claim strongly.
A common example is the shared service account. Several jobs run under the same principal, each with similar authority. Logs show activity and policy technically applies, but when production state changes, the system cannot clearly say which job exercised the permission. The control surface looks intact, yet attribution has already degraded.
The same problem appears in delegated execution. A tool call succeeds, but the identity boundary is unclear. Was the actor the user, the agent acting on behalf of the user, the broker translating the request, or the platform workflow executing under its own authority? If the runtime cannot distinguish those actors, the audit trail stops being very meaningful. The system can show that something happened, but not clearly who exercised authority.
That is the key distinction: weak identity is not just a permissioning problem. It is a system legibility problem.
Policy depends on identity attachment. Evidence depends on identity attribution. If the acting principal is unstable, shared, or collapsed across execution layers, controls become harder to apply precisely and incidents become harder to reconstruct confidently. A trace may show movement through the system, but without stable identity context it cannot explain who was authorized to do what.
The practical question is simple: can the runtime reliably say who or what is acting at the point where authority is exercised?
If the answer is no, the system is less governable than it appears.
Identity should be stable enough for control, telemetry, and evidence to attach to the same runtime actor.