Line of inquiry
Inquiring lines›How can multi-agent systems achiev…›What causes deception and coordina…›this line of inquiry
How should agents coordinate through shared persistent code artifacts?
A broader line of inquiry — a family of 46 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 46
Specific inquiring lines the field asks around this — ordered from the most general framing down to the most specific angle.
- Are durable shared code artifacts better than per-task harness patches?
- Can shared persistent artifacts between agents be properly governed?
- How do standardized artifacts reduce inter-agent communication failures?
- How do standardized artifacts prevent autonomous agent failure modes?
- How do standardized artifacts improve coordination between multiple tools?
- What breaks when multiple agents share and revise the same artifacts?
- How do agents decide which created code deserves long-term persistence?
- Can a package repository act as persistent memory for agent coordination?
- What prevents inconsistent state when multiple agents share artifacts?
- How do agents decide which created code should persist versus disappear?
- Can constraining shared resources alone prevent reconstruction by later agents?
- How do standardized artifacts improve coordination between writing agents?
- What prevents multiple agents from corrupting shared state in live artifacts?
- What would unified agent-to-agent and agent-to-tool protocols actually look like?
- What role does standardization play in multi-agent system ecosystems?
- Can unified state objects replace switching between decomposition and writing tools?
- How do ordinary web services enable persistence for distributed agent activity?
- How do shared artifact stores become security risks in multi-agent systems?
- How should human oversight apply to persistent agent-authored code?
- Can public wikis enable agent coordination without requiring infrastructure breaches?
- What makes persistent, shared code artifacts from agents hard to manage at scale?
- Should new agent protocols replace existing ones or layer on top of them?
- How does lineage preservation compare to conversation-based multi-agent coordination?
- When should agent-created code be promoted into permanent harness infrastructure?
- Can structured artifact sharing replace direct latent thought communication?
- Why does removing a communication channel not permanently prevent agent coordination?
- What makes protocols better than free-form prompting for tool coordination?
- How does storage-mediated coordination differ from direct agent messaging?
- How do structured APIs constrain misaligned communication compared to free text?
- Can deterministic function calls prevent agent failures better than protocol-mediated tool access?
- Why do a-priori procedural specifications fail as environments change and interfaces evolve?
- Can one-off agent code be safely promoted to durable infrastructure?
- How does shared storage differ from a message-passing hop in a pipeline?
- Can semantic-layer files be federated without losing accountability and ownership?
- What governance risks emerge when agents communicate in unreadable text?
- Why do workflow abstractions fail in embodied agent environments?
- Can versioned capability vectors solve the discovery gap in existing protocols?
- Can open agent workflows be modeled as finite event lifecycles?
- Can disposable agent-authored code be distinguished from reusable infrastructure?
- What makes a tool schema high-quality enough to prevent agent misuse?
- Why do rigid orchestration frameworks fail where generative environment specifications succeed?
- How did agents use a package service as a persistent message board?
- How much coordination benefit comes from the record versus other factors?
- What does it mean to constrain shared resources across multiple agent executions?
- Why does MCP's portability come with determinism failures in production workflows?
- Why do stateless protocols push coordination complexity into application code?