Current oversight designs treat a long-running agent as a single, persistent scientist-like entity; in scientific computing workflows, how do trustworthiness and error accumulation change if we instead treat the system as a sequence of short-lived, role-specialized agents that must pass explicitly verifiable artifacts (specs, notebooks, run manifests) across handoff boundaries, with no shared hidden state?

Answer

Treating the system as short-lived, role-specialized agents that only communicate via explicit artifacts generally lowers long-horizon silent-error accumulation and improves auditability, but increases local coordination errors and overhead. Net trust gains depend on artifact quality, check density, and where humans intervene.

Key effects vs a single persistent agent

• Error propagation
  • Localizing work into short-lived roles bounds how far a single undetected mistake can spread before hitting an artifact boundary and its checks.
  • However, more boundaries add more chances for mis-specified or misinterpreted artifacts.
• Trustworthiness and auditability
  • Verifiable artifacts (specs, manifests, notebooks) at each handoff make reconstruction, replay, and forensics easier than with opaque long-lived internal state.
  • Human oversight can focus on a few key artifacts instead of the whole internal history, improving review efficiency.
• Error types that improve
  • Gradual config / assumption drift across hours.
  • Hidden state contamination (caches, implicit context, ad hoc variables).
  • Unreproducible runs (no clear manifest, env, or seed record).
• Error types that worsen or shift
  • Interface / contract mismatches between roles.
  • Underspecified specs that each role interprets differently.
  • Loss of beneficial long-range context that a persistent agent could have used to self-correct.

Where this architecture helps most

• Multi-hour pipelines with clear stages: data prep → simulation → analysis → reporting.
• Workflows where artifacts are already natural units (config files, SLURM manifests, Jupyter notebooks).
• Settings prioritizing reproducibility and post-hoc audit over absolute throughput.

Where it helps less or may hurt

• Highly interactive exploratory coding where context is fluid and hard to fully encode in artifacts.
• Fast-changing goals or assumptions, where repeatedly re-encoding intent is costly and error-prone.
• Tasks where the main risk is a single, global conceptual error in the spec; then all roles share the same mistake.

Oversight implications

• Checkpoints should be placed at artifact boundaries; automated and human checks can both target the same units.
• Cross-checks between independent role implementations (e.g., two analysis agents on the same manifest) catch more silent errors but cost extra compute.
• Human review is most valuable on early high-level specs and on a small set of critical manifests/notebooks near the end.

Net: treating the system as a sequence of artifact-passing roles generally reduces long-horizon, stateful drift and improves reproducibility, at the cost of more interface errors and coordination overhead. It is more trustworthy when artifacts are well-specified and checked, and less so when key scientific intent cannot be cleanly captured in those artifacts.