Recoleta Item Note
Turn: A Language for Agentic Computation
Turn is a compiled language for "agentic computation" that makes LLM inference, context management, persistent state, and credential security into language primitives directly, rather than relying on framework…
agent-programming-languagellm-type-safetyactor-modelcapability-securityschema-driven-apis
Summary
Turn is a compiled language for "agentic computation" that makes LLM inference, context management, persistent state, and credential security into language primitives directly, rather than relying on framework conventions. The paper’s core claim is that many reliability and security problems in agent systems require language-level guarantees.
Problem
- Existing Python/TypeScript/Rust + agent framework approaches leave context boundaries, structured output, durable execution, state consistency, and credential isolation to be maintained manually at the application layer, which is prone to failure.
- This matters because agent programs delegate critical decisions to stochastic LLMs; if outputs are not type-constrained, context is unbounded, and credentials are visible, errors can accumulate, systems can crash, or secrets can leak.
- The paper explicitly lists 5 failure modes: unbounded context, untyped inference output, fragmented state, lack of durable execution, and credential leakage.
Approach
- It proposes Turn, a compiled actor language: dynamically typed at the value level, but with "targeted strictness" at high-risk boundaries.
- Using
infer Struct { prompt }, it turns LLM inference into a typed language primitive: the compiler automatically generates a JSON Schema from the struct, and the runtime VM validates the model output; if binding succeeds, it structurally conforms to the declared type. On failure, it can retry up to k=3 by default. - Using
confidence v, it exposes model confidence so programs can make deterministic branches based on thresholds; if the provider does not supply such a signal, it returns a default of 0.5. - Using an Erlang-based actor process model, it isolates each agent’s context, persistent memory, and mailbox, and supports durable execution with suspend/resume; the context uses a three-layer structure: P0 system, P1 working, P2 episodic, where P1 has a limit of 100 entries and P2 has a limit of 200 entries.
- Using
grant identity, it provides unforgeable, non-stringifiable, non-serializable capability handles to isolate credentials; it also usesuse schema::<protocol>(...)to absorb external API schemas at compile time and generate typed bindings.
Results
- The paper provides very limited quantitative experimental results; the abstract says it was "evaluated on representative agentic workloads," but the excerpt provided here does not give specific benchmark metrics, accuracy, latency, or ablation numbers.
- The clearest formal/mechanistic result is that the paper claims and proves a structural conformance property: if an
inferexpression completes without error, then every field of the bound value conforms to the declared struct type. - The context design cites attention phenomena from external research to support its motivation: in long contexts, information recall is about 90% at the beginning, about 85% at the end, and about 50% in the middle; Turn uses the P0→P2→P1 rendering order to place critical content in high-recall positions.
- As for execution examples, the paper claims that an "investment committee" multi-agent program uses only 89 lines to cover its 5 core language mechanisms, and demonstrates 3 specialized actors performing concurrent analysis, fallback based on a 0.7 confidence threshold, and I/O with scoped credentials.
- The paper also cites existing empirical evidence showing that agent reliability decreases exponentially with the number of loop iterations: if the single-step success rate is 0.95, then after 20 steps the overall success rate is about 0.36; Turn uses this as motivation for type boundaries and deterministic repair routing, rather than as an experimental improvement result of its own.
Link
Built with Recoleta
Run your own research radar
Turn arXiv, Hacker News, OpenReview, Hugging Face Daily Papers, and RSS into local Markdown, Obsidian notes, Telegram digests, and a public site.