Weekly Research · 004

Authority Is a Lifecycle, Not a Setting

Durable agent work needs explicit admission, bounded execution leases, lifecycle revalidation, revocation reconciliation, and independent acceptance.

W004Published 2026-08-09简体中文 →

Weekly 004 — Authority Is a Lifecycle, Not a Setting

Evidence scope

This synthesis uses only evidence-validated Daily Research published in the seven-day window 2026-08-03 through 2026-08-09. No eligible Daily Runtime publication exists for August 3 or August 4. From August 5 through August 9, five Daily Runtime V5 records are Completed, each with publication = Completed.

That leaves 15 eligible Daily Research notes: five in Digital Employee, five in Industry Architecture, and five in Open-source Engineering. Every note used here is published on main, declares evidence_status: Completed, points to a same-day Research Object and Reading Result, and preserves its own limitations and counter-evidence. Academic observations, Weekly reports, manually published field cases, unselected signals, and unpublished candidates are excluded.

Date	Digital Employee	Industry Architecture	Open-source Engineering
2026-08-05	Independently accepted completion	Governed model routing	Guardrail persistence state machine
2026-08-06	Governed revisable work graph	Enterprise decision envelope	Semantic migration and recovery
2026-08-07	Verification-gated state admission	Role-aware agent resource plane	Stable-identity provisioning gate
2026-08-08	Pause-preserving budget admission	Lifecycle-revalidated policy plane	Correlated multi-stream host contract
2026-08-09	Revocation-coupled run reconciliation	Rotating assertion → short-lived credential	Executed conformance for migration safety

The evidence base is therefore large enough for cross-day synthesis, but still narrow in time. The report makes architecture and engineering judgments from repeated mechanisms; it does not claim a market-wide empirical trend.

Executive synthesis

The week’s fifteen notes appear to cover different problems: completion, routing, mutable work graphs, session recovery, budgets, resource scheduling, credentials, remote streams, provisioning, migration, and cancellation.

They converge on one control-plane fact:

The durable unit that must be governed is not “the agent session.” It is every transition that grants, preserves, changes, pauses, revokes, or accepts execution authority.

A static permission bit is insufficient because long-running work crosses time. A model can resume under new policy. A graph node can become dependency-ready without being authorized. A budget can pause new work while preserving accepted state. A credential can remain valid for minutes after its source rotates. A deletion can revoke database authority while a remote worker is still physically running. A final result can be correct while the migration mechanism has violated its bounded-replay contract.

The new weekly conclusion is therefore:

Authority is a lifecycle. Reliable agent runtimes need an Authority Lifecycle Control Plane that separates canonical work identity, admission, bounded leases, revalidation, revocation, reconciliation, evidence, and acceptance.

Trend synthesis — from static configuration to transition-time authority

Across all three columns, control is moving away from one-time configuration and toward transition-time decisions.

Digital Employee research repeatedly shows that durable state and execution readiness are not authority:

• completion must be independently accepted;
• graph readiness proves dependency readiness only;
• persisted memory must pass state admission before shaping future work;
• budget exhaustion should pause admission rather than destroy work state;
• context deletion must revoke authority and reconcile unsettled children.

Industry Architecture reaches the same conclusion from a different direction:

• model routing optimizes inside policy rather than defining policy;
• consequential execution needs a decision envelope with policy provenance and actual runtime identity;
• resource scheduling must remain subordinate to trust and business constraints;
• policy must be revalidated at resume, fork, model change, and material settings transitions;
• rotating assertions should derive short-lived credentials, with propagation governed separately.

Open-source Engineering exposes why this cannot remain a conceptual governance layer:

• accepted output and replay evidence need different persistence states;
• semantic migration requires recoverable publication and logical invariants;
• stable resource identity needs explicit lifecycle admission;
• multi-stream protocols require correlation, acknowledgement, and drain watermarks;
• migration safety requires conformance that actually executes against governed backends.

The repeated mechanism is not “more safety checks.” It is a shift from configuration authority to transition authority.

A useful lifecycle is:

proposed state
→ admitted authority
→ bounded execution lease
→ observed execution
→ revalidation at material transition
→ reconciliation after interruption or revocation
→ independent acceptance

The key implication is temporal: authorization has an age. A decision that was valid at creation time may not remain valid after policy, identity, model, budget, resource, or work context changes.

Architecture synthesis — Authority Lifecycle Control Plane

The fifteen Daily notes support a new architecture abstraction that was not stated by any single source: an Authority Lifecycle Control Plane.

Canonical Work Identity
        ↓
Authority Admission
        ↓
Bounded Execution Leases
        ↓
Execution + Evidence
        ↓
Lifecycle Revalidation
        ↓
Revocation + Reconciliation
        ↓
Independent Acceptance
        ↓
Accepted State / Governed Recovery

Evidence / Receipts / Executed Conformance
span every transition.

1. Canonical Work Identity

Long-running work needs an identity that survives provider sessions, model substitutions, worker restarts, provisioning state changes, and UI projections.

The stable object may be a WorkOrder, campaign, task, or logical resource, but its identity must remain distinct from:

• a provider conversation;
• a worker process;
• a remote host session;
• a temporary access token;
• a readiness payload;
• a dashboard projection.

This is the precondition for recovery. Without canonical identity, lifecycle state tends to be encoded by replacement objects, hidden transcripts, or whichever process happens to be alive.

2. Authority Admission

Before a consequential unit of work begins, the runtime needs an explicit answer to: is this work allowed now?

Admission may combine:

• Position or role authority;
• current organization policy;
• requested capability;
• actual model and sandbox;
• budget state;
• dependency readiness;
• resource/trust constraints;
• accepted reusable state;
• required human or independent review.

This is where the week’s Digital Employee state-admission pattern meets the Industry Architecture decision-envelope and policy-revalidation patterns.

3. Bounded Execution Leases

A durable Running flag is too weak for real execution. Worker authority, credentials, budget headroom, and opportunistically reclaimed capacity are all bounded resources.

The common pattern is a lease:

owner
+ scope
+ issued_at
+ expiry / renewal
+ revocation
+ acknowledgement
+ fencing

The exact semantics differ. A credential lease is not a worker lease; a budget gate is not a CPU lease. But all need explicit duration and a way to prevent stale authority from surviving indefinitely.

4. Lifecycle Revalidation

Resume, fork, model fallback, settings mutation, resource reassignment, and recovered state can all reactivate old work.

Revalidation asks whether the authority conditions that admitted the work still hold. Durable history may remain unchanged while executable authority is recalculated.

This separates two promises:

• historical durability — preserve what happened;
• authoritative durability — preserve only the state still allowed to shape future work.

5. Revocation and Reconciliation

Revocation is not equivalent to deletion, local cancellation, or hiding a UI object.

A governed revocation must reconcile:

• queued work;
• approval-waiting work;
• physically running workers;
• outstanding remote waits;
• valid but no-longer-desired credentials;
• in-flight external side effects;
• occupied resource slots;
• stale late results.

Database truth, physical execution, and external effects can diverge. Reconciliation is the process that brings them back inside one bounded authority model.

6. Independent Acceptance

Completion is not the last tool call or the worker’s final sentence.

The same architecture needs a final transition from a completion claim to an accepted outcome. Depending on consequence, that may be:

• deterministic state readback;
• role-separated QA;
• a policy verifier;
• human authority;
• a combination of these.

Acceptance authority must be independent from mere evidence persistence and must record who or what accepted the result.

Engineering synthesis — correctness includes mechanism invariants

A second cross-week conclusion is that correct visible output is not sufficient evidence that the runtime behaved correctly.

The week contains several versions of the same hidden failure:

• a persisted state can be durable but not admitted;
• a managed policy can exist but not govern every execution path;
• a migration can reconstruct the correct final list while replaying the entire history;
• a remote close event can arrive before earlier callbacks have drained;
• a local cancel can stop waiting without proving the remote worker stopped;
• a short-lived token can still be copied into an unintended child process;
• a Ready resource can exist without proving connection/use began;
• a graph node can be dependency-ready without permission to execute.

This changes what a release gate must verify.

Output contract

Did the user-visible or business result become correct?

Mechanism contract

Did the system preserve the control invariant promised by the architecture?

Evidence contract

Can the runtime prove which identity, policy, model, sandbox, resource, verifier, and transition governed the outcome?

For agent infrastructure, all three increasingly matter.

Cross-column implications

State admission × policy revalidation

Digital Employee state admission and Industry policy revalidation are two halves of one Effective Authority Snapshot.

A stored memory, checkpoint, route, completion verdict, or resumed context should influence future work only after the current policy plane admits it. This avoids a persistent state becoming a permanent exception to policy change.

Decision envelope × enforcement receipt

Industry Architecture can decide which configuration should apply, but Open-source Engineering must prove what actually executed.

A decision envelope therefore needs a corresponding enforcement receipt:

decision:
  policy_version
  principal
  capability
  requested_model
  allowed_sandbox

receipt:
  actual_model
  actual_sandbox
  credential_scope
  execution_id
  policy_version_applied
  evidence_refs

Without the receipt, governance remains an intention rather than an execution fact.

Durable protocol × transport/storage conformance

Business semantics such as pause, resume, revoke, and accept cannot be reliable when the underlying host or store silently reorders, replays, skips conformance, or duplicates a side effect.

Transport and storage layers do not own business authority, but they must satisfy the invariants that make that authority reconstructible.

Resource efficiency × trust boundary

Role-aware resource scheduling improves efficiency only inside authority and trust constraints.

A profiler may identify spare capacity, yet collocation remains invalid when tenant, credential, sandbox, business-priority, or side-effect boundaries prohibit it. Efficiency policy is subordinate to trust policy.

Contradictions identified

1. Durability versus stale authority

Durability helps recovery, but old state can become a bypass if it automatically regains execution authority after policy changes.

Resolution direction: preserve history broadly; admit reusable state narrowly and revalidate at authority-returning transitions.

2. Parallelism versus revocation and finality

Ready DAG nodes and independent transport streams increase concurrency. They also multiply races, late results, and cross-stream finality problems.

Resolution direction: add leases, sequence evidence, drain watermarks, and fencing before treating parallel completion as settled.

3. Short-lived credentials versus containment

A shorter token lifetime reduces the exposure window. It does not prove least-privilege propagation.

Resolution direction: manage credential lease and propagation policy separately, with delegation receipts at child-process and remote boundaries.

4. Central policy versus control-plane bottlenecks

Central policy improves consistency but may become a latency or availability dependency, especially when revalidation is required frequently.

Resolution direction: define which signed or versioned decisions may be cached, for how long, and which transitions require synchronous refresh.

5. Local idempotence versus distributed exactly-once

Stable identity and in-process locks can make local ordering reliable. They do not prove that a remote provisioning action, business mutation, or tool side effect happened exactly once across crashes.

Resolution direction: use external idempotency keys, effect receipts, and recovery reconciliation rather than widening local guarantees.

6. Correct output versus valid mechanism

Value-only tests may pass while replay, migration, or policy-path behavior violates the system’s design contract.

Resolution direction: encode replay/query bounds, backend execution coverage, policy-path coverage, and settlement conditions in conformance tests.

Prediction — the next control-plane layer

The following are Research Center predictions derived from the repeated weekly mechanisms, not claims made by the Daily sources.

1. Authority transitions become first-class events. Agent platforms will expose admitted, leased, paused, revalidated, revoked, fenced, and accepted instead of inferring them from a generic status.
2. Memory splits into history and admitted state. Long-running systems will store more evidence but trust less of it automatically.
3. Lease patterns converge. Worker leases, credential leases, budget admission, and resource reclamation will increasingly share owner, scope, expiry, renewal, revocation, and fencing concepts.
4. Conformance becomes behavioral. Release gates will assert replay limits, drain watermarks, non-skipped backend coverage, and policy-path execution in addition to final values.
5. Observability moves from traces to receipts. Traces explain what code did; receipts will prove which authority actually governed a consequential execution.

These predictions are directional. The evidence window is five active Daily Runtime days and does not establish adoption rates or timelines.

Unresolved questions

1. How fresh must policy be at each authority transition, and which versioned decisions may be safely cached?
2. Can worker, credential, budget, and resource leases share one minimal schema without flattening their different failure semantics?
3. How should stale workers and credentials be fenced after authority is revoked or replaced?
4. Who owns compensation when an external side effect arrives after cancellation or revocation?
5. How can independent acceptance scale without turning QA or human authority into the dominant throughput bottleneck?
6. Which behavioral invariants must become non-skippable conformance gates for every governed backend?
7. Which authority semantics belong in FCoP protocol facts and which should remain CodeFlowMu Runtime projections?
8. How should resource optimization prove that trust, tenant, sandbox, and credential isolation survived capacity reclamation?

Next-week priorities

Priority	Work	Why now
P0	Draft an Authority Transition Contract research schema	The same transition semantics recur across state, policy, workers, credentials, budgets, and completion.
P0	Prototype CodeFlowMu worker leases and revocation fencing	Revocation currently needs a bounded way to make physical execution converge.
P0	Build historical Runtime conformance fixtures and non-skippable backend coverage	The week shows that compatibility and test execution are separate facts.
P1	Add credential delegation receipts	Short lifetime is not evidence of containment.
P1	Separate budget admission, settlement, and authorized resume	Economic authority needs explicit lifecycle semantics.
P1	Add role-aware Runtime telemetry	Resource optimization needs control/runner/inference visibility without weakening trust constraints.

The priority is not to create a larger protocol. The first target is executable Runtime evidence. Only repeated pressure that cannot be represented with existing FCoP facts should motivate protocol change.

Implications for CodeFlowMu, FCoP, and Digital Employee

CodeFlowMu

CodeFlowMu should treat worker execution as a lease, not as an unbounded Running flag. PM/QA/ADMIN authority, model and sandbox identity, budget admission, credential propagation, and recovered context should be revalidated at material lifecycle boundaries.

The Runtime should make late-result fencing and effect receipts explicit before expanding unattended computer-use autonomy.

FCoP

FCoP should remain the shared behavioral fact surface rather than absorbing transport ordering, process leases, credential exchange, or resource scheduling.

The useful question for future protocol pressure is narrower: which authority transitions need to be visible and reconstructible across independent runtimes? Until multiple runtimes require new protocol semantics, the application/runtime layer should carry the operational mechanism.

Digital Employee

A Digital Employee Position is not merely a role plus skills. Its effective authority changes over time as work is admitted, delegated, paused, resumed, revalidated, revoked, and accepted.

Position definitions therefore need durable ownership and authority references, while WorkOrder Runtime state needs the evidence that proves which authority was effective at each consequential transition.

Boundary and counter-evidence

This Weekly synthesis is bounded by the available Daily corpus.

• The evidence window is seven days, with formal V5 Daily Research on five days.
• Most implementation evidence comes from first-party documentation, maintainer changes, and associated tests, not independent production replication.
• Resource, verifier, migration, and credential results have workload- or implementation-specific boundaries.
• The evidence does not prove one universal Authority Lifecycle Control Plane across all agent platforms.
• The architecture and predictions in this report are new Research Center synthesis. They are not retroactively attributed to any single Daily source.
• No Daily article, Research Object, Reading Result, or Runtime Record was modified by this synthesis.

Conclusion

The previous Weekly synthesis identified ownership as the control plane of agentic work.

This week extends that insight across time.

Ownership answers who is responsible. Authority lifecycle answers when that responsibility is allowed to execute, how long it remains valid, when it must be checked again, how it is revoked, and who may finally accept the result.

The recurring architecture can be stated compactly:

Admit authority deliberately. Lease it for bounded execution. Revalidate it when material context changes. Reconcile it when work is interrupted or revoked. Accept completion independently.

That is the control-plane pattern connecting memory, policies, budgets, credentials, workers, migrations, remote hosts, and completion evidence across the week.

References

1. Digital Employee — Independently Accepted Completion
2. Industry Architecture — Governed Model Routing
3. Open-source Engineering — Guardrail Persistence State Machine
4. Digital Employee — Governed Revisable Work Graph
5. Industry Architecture — Enterprise Agent Decision Envelope
6. Open-source Engineering — Semantic Migration Recovery
7. Digital Employee — Verification-Gated State Admission
8. Industry Architecture — Role-Aware Agent Resource Plane
9. Open-source Engineering — Stable-Identity Provisioning Gate
10. Digital Employee — Pause-Preserving Budget Admission
11. Industry Architecture — Lifecycle-Revalidated Policy Plane
12. Open-source Engineering — Correlated Multi-Stream Host Contract
13. Digital Employee — Revocation-Coupled Run Reconciliation
14. Industry Architecture — Rotating Assertion → Short-Lived Credential
15. Open-source Engineering — Executed Conformance for Migration Safety
16. Daily Runtime Record — 2026-08-05
17. Daily Runtime Record — 2026-08-06
18. Daily Runtime Record — 2026-08-07
19. Daily Runtime Record — 2026-08-08
20. Daily Runtime Record — 2026-08-09