acceptodds
Under review as a conference paper at ICLR 2027

Linden: Linear-Typed Agent Collaboration

Abstract

Collaboration among language-model agents is becoming increasingly common, making safe coordination over shared resources a central systems concern. Sandboxing provides a meaningful initial authority boundary, but not a dynamic mechanism for reallocating and transferring authority as collaboration evolves. We present **Linden**, a system for agent collaboration grounded in linear types. Linden represents resources and their update authority as linear values—values that must be consumed exactly once rather than duplicated—thereby enforcing unique ownership while allowing authority to move between participants. Resource versions and collections follow the same typed ownership discipline. A read-only projection separates shared access from update authority, while a monad captures runtime-mediated observations of shared state. Humans, agents, and terminals inhabit a common participant tree whose parent–child relationships constrain resource and authority transfers. We formalize Linden in a core calculus and prove type safety, unique ownership, role authenticity, capability confinement, and atomic observation. An executable language and a runtime authority manager enforce these guarantees during agent execution. Beyond semantic conformance tests and runtime microbenchmarks, we evaluate Linden on general-purpose terminal tasks, small-team coding, and large-scale multi-agent collaboration. On Terminal-Bench 2.1, Linden improves task success by 8.1 percentage points over a conventional sandbox baseline. On CooperBench Flash, Linden-Coop scores 3.4 points above Pi-Coop, while Linden-Team reaches 89.7%, the highest success rate among all evaluated conditions, including Shepherd. On Silo-Bench, Linden reaches 76% success on the common completed set, 28 percentage points above the strongest baseline, and coordinates 100 Agents in a chain-structured task through direct handoffs and independent recomputation.

Primary area:
infrastructure, software libraries, hardware, systems, etc.
Keywords:
Multi-agent systems, Linear types, Resource ownership, Capability-based security, Agent orchestration

Reviews

Among:
Shape:
1234this paper, Bottom 10%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 1.67 over 3 reviews, above 10% of the others.
Reviewer_vFDeOpenReview ↗
Rating
2
Confidence
1
Informativeness
3
Presentation
2
Soundness
2
Read review
Paper summary

This paper presents a system for agent collaboration grounded in linear types called Linden and formalizes it in a core calculus and prove type safety, unique ownership, role authenticity, capability confinement, and atomic observation. On Silo-Bench, Linden reaches 76% success on the common completed set and coordinates 100 Agents in a chain-structured task through direct handoffs and independent recomputation.

Critical strengths

As for me, this is a novel method and perspective for agent collaboration, and experiments are extensive.

Critical weaknesses
  1. The formal properties covered are limited to permission safety—ensuring exclusivity of write access and preventing further delegation after transfer. These properties say nothing about whether the agent that holds the permissions actually produces correct or sensible code modifications. Since the paper's central motivation is reliable multi-agent coordination, guaranteeing permission hygiene without guaranteeing output correctness leaves the core problem unsolved, and the current experiments are insufficient to compensate for this gap.

  2. The writing includes statements such as "making safe coordination over shared resources a central systems concern," which is too categorical for a scientific paper and overstates the contribution. Combined with figures that are unclear and an overall writing style that lacks rigor, the presentation is below the standard expected for publication.

Questions for authors
  1. The paper format appears to differ from other submissions; it is unclear whether this violates the submission format requirements.
  2. The writing and figures have substantial room for improvement. For example, the statement "making safe coordination over shared resources a central systems concern" is overly absolute for a scientific paper. The figure quality also needs improvement.
  3. The theoretical guarantees mainly concern permission-level properties—e.g., write permissions are not held concurrently, and transferred permissions cannot be further used. However, whether the agent holding the permissions actually modifies the code correctly still requires more validation; the current experiments are not convincing enough.
2 comments
AuthorsOpenReview ↗

Response to Reviewer vFDe

Thank you for recognizing the potential of the approach. We have clarified the scope of our claims in the abstract and introduction and fixed the formatting.

1. Scope of the guarantees. Our study concerns general mechanisms for organizing and controlling agent collaboration. A universal correctness guarantee across arbitrary tasks would encompass program correctness, which is undecidable in general. Linden focuses on coordination rules that can be specified and enforced across different agents and tasks. Rice, 1953

Linden enforces unique update authority, removes the sender's authority after a transfer, and prevents local rewind from restoring it. Even when an agent makes a wrong decision, the resources it can modify remain bounded by its granted authority. Its parent can intervene by stopping the task and reclaiming delegated resources. The inference-batching example in Figure 2(b) and Appendix G.1 illustrates this mechanism.

2. Formatting and figures. We used the official ICLR template. The earlier LaTeX compilation had missing fonts; this has now been corrected. We have also corrected figure labels and aligned their notation with the text.

Thank you for the clarification and revisions. I recognize the value of permission safety and agree that universal correctness guarantees are beyond the scope of this work. However, I remain concerned that the current experiments do not sufficiently establish how the permission mechanism improves collaboration reliability. More direct evidence of reduced coordination failures would help address this concern.

Reviewer_sXfUOpenReview ↗
Rating
1
Confidence
3
Informativeness
1
Presentation
1
Soundness
1
Read review
Paper summary

The paper introduces Linden which is a language and runtime for multi-agent collaboration using linear types to enforce unique update authority and structured resource transfers. Validation includes conformance tests, runtime microbenchmarks, and evaluations on Terminal-Bench, CooperBench Flash, and Silo-Bench. Experiments show improved task success under the evaluated configurations.

Critical strengths
  1. The paper investigates resource ownership and authority transfer as explicit problems in multi-agent collaboration, which I think is a practical problem to study.
Critical weaknesses
  1. The overall narrative is hard to follow and understand.
  2. The manuscript needs substantial technical editing. Notation is insufficiently explained and misused, and the prose is repetitive and often imprecise about the scope of its claims. These issues give the impression of AI-generated drafting without sufficient technical review.
Questions for authors

I have no specific clarification questions. Please see my comment in the above weaknesses.

3 comments
AuthorsOpenReview ↗

Response to Reviewer sXfU

Thank you for your comment. Our paper introduces many concepts, while placing some definitions and explanations of notation in the appendices, which made the main text harder to follow.

To improve readability, we have revised the notation and figure labels, including adjustments to a few symbols for clarity and consistency. The formal type syntax and typing rules are given in Appendix A, with the transition rules in Appendix B.

The soundness argument and accompanying proofs were already included in Appendix C of the original submission. The argument proceeds through preservation and relative progress. Transfers move authority without copying it, path refinement preserves disjoint ownership, and history navigation cannot restore transferred authority. These invariants are preserved across core transitions and underpin the stated safety results.

Thank you for your response. Could you please update the manuscript with highlighted changes?

AuthorsOpenReview ↗

Response to Reviewer sXfU

Thank you for following up. The AuthorGuidelines says that there is a pdfdiff to compare new changes to the paper against the original submission. We were unsure whether additional highlighting within the submitted PDF was expected, so we have also listed the main changes below.

  • Notation and figures (Section 3 and Appendix A). We use distinct symbols for resource types and path regions, and for wait states and participant roles. We also corrected the context labels in Figure 1, which shows the writer's local typing judgment, and Figure 2(a), which shows the runtime check. We fixed the missing fonts in the compiled PDF.
  • Motivation (abstract and introduction). We now identify race conditions and unauthorized actions as the specific coordination problems we study. The introduction gives examples of agents overwriting one another's work and describes the effort required to merge isolated changes and recover the context behind them.
  • Runtime enforcement (Appendix E, Tables 2–3). We explain how the runtime enforces the ownership rules. For example, after a file is transferred, the sender can no longer write to it through a broader directory grant.
  • Evaluation (Section 5.1 and Appendix F.1). We describe what the enforcement tests check. Of the 117 passing checker and runtime tests, 28 specifically examine agreement between authority checks, committed state, and physical execution.

For reference, the original submission already included the typing rules in Appendix A, the operational semantics in Appendix B, and the soundness argument, including preservation and relative progress, in Appendix C.

Reviewer_a39COpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

Linden is a language and runtime for multi-agent collaboration that treats write authority as a linear resource: a participant can transfer it, but cannot duplicate it. Read-only pointers allow shared observation, and a participant tree governs delegation and lifecycle operations. The paper gives a core calculus with safety properties, implements a checker and runtime with sandboxed terminal execution and versioned files, and evaluates the system on Terminal-Bench, CooperBench, and Silo-Bench. The results suggest the overall system can support useful collaboration with modest overhead, though the experiments do not isolate the effect of linear authority from other design choices.

Critical strengths
  • The separation between unique write authority and copyable read access is clear and well suited to the problem. The participant tree gives delegation and lifecycle control a consistent structure, and the versioning design avoids restoring old authority when a resource is rewound.
  • This is more than a formal proposal: the authors implement a language and runtime, report enforcement tests and overhead, and provide concrete collaboration traces. The low measured read and write overheads make the approach plausible as a practical system.
Critical weaknesses
  • The need is plausible, but the introduction should explain what current agent platforms still cannot do. Public documentation already describes sandbox and approval controls in Codex, resumable managed sessions and subagents in the OpenAI Agents API, and sandboxed managed agents in Google’s Gemini API (Codex controls, OpenAI Agents API, Google managed agents). These offerings address parts of the access and continuity problem, though their public descriptions do not establish typed, per-resource authority transfer. The paper also does not show how often current workflows hit a limitation that these controls leave open. Its benchmark comparisons change several factors alongside Linden’s typing: Terminal-Bench delegation uses about 2.32 times the tokens and 2.60 times the tool calls of Linden without delegation; CooperBench gives Linden-Team a pure manager and more model agents than Pi-Team; and Silo-Bench compares asynchronous Linden with round-synchronous baselines. The results support end-to-end system feasibility, but not the need for or effect of typed authority itself. The 76% Silo score is from 25 commonly completed instances; across all initiated trials Linden succeeds on 27/120.
  • The formal guarantees are proved for the core calculus, whose operations are atomic. The implementation also has to reconcile physical shell writes, snapshots, and runtime epochs; the paper calls the connection to the calculus a refinement obligation but does not establish it. The 117 enforcement tests are useful evidence of implementation behavior, but they do not fully close this gap. Since safe authority management is the central motivation, the paper should state more precisely what the running system guarantees and under which assumptions.
Questions for authors
  1. Problem relevance: What recurring failure in current agent workflows is not handled by sandbox boundaries, scoped permissions, and session-level approvals? Can you provide evidence of how often it occurs and explain what typed handoff adds to current frontier-agent systems?
  2. Clarification: What is the precise connection between physical writes and epoch reconciliation in the runtime and the atomic transition in the calculus? Which physical behaviors are outside the guarantees?
1 comment
AuthorsOpenReview ↗

Response to Reviewer a39C

Thank you for recognizing the potential of the approach. We appreciate your comprehensive review of our paper and we have expanded the introduction and Appendix E to address your questions.

1. Existing harnesses and the gap addressed by Linden. We have expanded the introduction with a more detailed analysis of current agent harnesses, including Codex, Claude Code, Cursor, GitHub Copilot, and Devin.

The revised introduction shows coordination issues of sandboxes and approvals used by current harnesses. For example, Claude Code recommends assigning different files to teammates to avoid overwrites, and warns that the lead may start implementing tasks already assigned to others. These cases still rely on agents respecting the division of work. Claude Code documentation

Also, isolated workspaces introduce integration costs. Cursor reports that its integrator, responsible for rebasing, resolving conflicts, and merging changes, became a bottleneck for hundreds of workers. Its handoffs also include concerns, deviations, and discoveries, illustrating the additional communication needed to preserve context beyond the code changes. We discuss these costs and the risk of losing decision context in the revised introduction. Cursor’s report

Linden addresses these problems by enforcing unique write authority in a shared workspace: transferring a resource also removes the sender’s authority to modify it. Participants can therefore coordinate directly over shared resources without producing isolated copies that must later be merged. They retain their local context for continued discussion, allowing collaborators to revisit assumptions and intermediate findings beyond the returned patch or summary.

2. How the runtime implements the guarantees. Appendix E now connects the formal invariants to the implementation: ownership and version checks, structural-role validation, filesystem enforcement, and joint publication of authority and resource-state changes. For physical writes, native File reads use the previous committed snapshot until reconciliation publishes the completed changes as one transition. This guarantee concerns Linden-mediated observations and depends on the adapters and sandbox enforcing the recorded authority.

Section 5.1 and Appendix F.1 also expand the description of the 117 passing checker/runtime tests, including 28 tests focused on semantic enforcement. These check transfers, physical access, revision, failure handling, and recovery. They provide concrete evidence of the correspondence described in Appendix E.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.