Line of inquiry
Inquiring lines›How can we ensure AI systems remai…›How can we design agent systems th…›this line of inquiry
How should persistent agent-authored code be governed and shared?
A broader line of inquiry — a family of 82 specific questions the research asks around this. Follow one into its inquiring-line page, or move sideways to a related line below.
Questions in this line of inquiry 82
Specific inquiring lines the field asks around this — ordered from the most general framing down to the most specific angle.
- How do agents decide which created code deserves long-term persistence?
- Are durable shared code artifacts better than per-task harness patches?
- How do agents decide which created code should persist versus disappear?
- Do agent improvements discovered on code tasks transfer to non-coding domains as well?
- How should agents decide which created code is worth persisting?
- How should human oversight apply to persistent agent-authored code?
- What prevents inconsistent state when multiple agents share artifacts?
- Can shared persistent artifacts between agents be properly governed?
- Can constraining shared resources alone prevent reconstruction by later agents?
- What breaks when multiple agents share and revise the same artifacts?
- What permission models govern code execution within agent skills?
- How should harness infrastructure validate code that agents generate themselves?
- What prevents multiple agents from corrupting shared state in live artifacts?
- Should agents preserve user-duplicated work separately from their own ongoing tasks?
- Can skill libraries prevent redundant narrow artifacts from proliferating?
- When should agent-created code be promoted into permanent harness infrastructure?
- Can one-off agent code be safely promoted to durable infrastructure?
- What makes persistent, shared code artifacts from agents hard to manage at scale?
- Can unified state objects replace switching between decomposition and writing tools?
- Does codifying domain rules into agent scaffolding work at library scale?
- How can agents distinguish between local edits and changes meant to propagate?
- How do agent-created code artifacts become part of harness infrastructure?
- What design practices prevent tool manifests from varying across requests?
- How do shared artifact stores become security risks in multi-agent systems?
- How should AI skills be created and managed like software artifacts?
- What role does peer activity play in triggering protected test modifications?
- Can skill validation through testing prevent unreliable programs from accumulating?
- What design patterns help preserve superseded plans for later reference?
- Why does forcing agents to trace function paths prevent unsupported claims?
- Does held-out validation prevent skill document edits from drifting or accumulating harm?
- Can disposable agent-authored code be distinguished from reusable infrastructure?
- What lifecycle management prevents in-loop skill creation from bloating an agent?
- Why do a-priori procedural specifications fail as environments change and interfaces evolve?
- Can the policy oracle itself be written to by agents in the pipeline?
- How do artifact families differ in matching verification scope to repair capability?
- When do agents benefit most from reusable workflow routines?
- What makes a tool schema high-quality enough to prevent agent misuse?
- What makes shareable agent artifacts spread faster than shared platforms?
- How do agents inherit exploit knowledge through shared history?
- How does the execution layer constrain agent performance in tool use?
- What makes agent-initiated artifacts the underexplored frontier in harness engineering?
- What specific practices do developers use to prevent agent mistakes upfront?
- What security risks emerge from giving agents durable corporate storage?
- Does AIDE2 archive rejected variants the way evolutionary approaches do for future reuse?
- How does Progent's stateful policy differ from single-step authorization checks?
- Can environment mismatches cause failures even when individual agents work correctly?
- How should skills be trusted and installed on sharing platforms?
- How should agentic workflows cost per artifact instead of per token?
- Why did older robot scientists log auditable provenance while LLM agents inherited only generation capability?
- How should versioning and rollback govern the fast scaffold update loop?
- What makes certain agent actions categorically high-risk and unrecoverable?
- What makes durable code artifacts more valuable than per-task harness patches?
- How can agents distinguish between optional and required form fields during execution?
- Why do plausible edits fail when applied to running executable systems?
- Why treat tutorial videos as a separate supply line from agent trajectories?
- How do long-horizon objectives drive agents to secure their own compute resources?
- How visible is the optional shortcut to the agent during task execution?
- Why can agent-restored files pass correct checks but violate task intent?
- What does it mean to constrain shared resources across multiple agent executions?
- Does AIDE2's guard against bad wins sit inside or outside the rewritable code?
- How much coordination benefit comes from the record versus other factors?
- Why do internally built AI tools become difficult to maintain over time?
- How did agents use a package service as a persistent message board?
- How do skills authored in-loop validate faster than offline generated skills?
- Can an agent weaken a test or restore files to change what the grader checks?
- How does shared state convert temporary compromise into persistent inherited risk?
- Why do agents modify protected tests only with unrestricted tools available?
- What metadata properties make code-derived skills auditable and comparable to their original source?
- How do agents discover and construct new APIs from existing applications?
- How do agents retrieve and compose skills from hierarchical multimodal wikis?
- What happens when an agent's provisioned access doesn't fit the actual task?
- What signals indicate a user is reusing partial outputs the agent created?
- Can agents acquire new skills online when offline skill coverage runs out?
- What design properties make permissions actually revocable over time?
- Did AIDE2's rewrites solve problems on a human checklist or search artifacts?
- What makes skills suitable for retrieval and chaining in repositories?
- Did internal safety rules fail to stop the PocketOS database deletion incident?
- What validates whether a rewritten agent is actually better?
- Can curator modules trained on one executor transfer to entirely different agent backbones?
- How does Claude Code prevent git credentials from leaving the sandbox?
- Where does an agent's risk come from across its components and sequence?
- What makes a distilled skill verifiable and ready for agent execution?