BROCA: Giving Agent Recipes a Grammar — A Gradual Type System and Combinator Algebra for Self-Composing Workflows

Abstract — v1.1, 14 June 2026

How it works, in one minute

• Typing is opt-in and additive — never a migration. A step may declare out: (a JSON-Schema object) and in: (named ports bound from earlier steps’ typed outputs). A step that declares neither keeps its exact prose behavior. The directive parser enforces this precisely: a line that begins out: but is not JSON-shaped is treated as ordinary prose, not an error. Three similar steps stay three similar steps; you type one when the guarantee matters.
• Compile-time contracts catch mis-wired recipes before a single subagent is spawned. At seed time the runner checks every in: port and every when: guard reference: is the referenced step real? Strictly earlier? Does its out: schema declare the field? If any check fails, the run is refused with a precise, human-readable message. A skill’s output schema is adopted at compile so even invoke skill: steps type-check downstream. Integration errors that used to surface deep in a live run surface at authoring time instead.
• A sandboxed boolean grammar, not eval. The when: directive is an OR-of-AND-of-comparisons over earlier steps’ typed fields and JSON literals. No parentheses, no arithmetic, no function calls, no path to arbitrary code. A workflow document that an agent authors and a nightly loop mutates must never become an injection vector — the closed grammar is the guarantee, not a lint rule.
• A combinator algebra over typed array edges with dynamic workers. map: and filter: iterate a worker recipe over a typed array; the worker can be a {{steps.n.out.worker}} reference resolved at dispatch — the recipe applied across a collection is selected by an earlier step’s structured decision. Composition depth ticks once for the whole map step, not once per element. if-then-else is the when:-guard plus return:/done:-exit pair — no new machinery needed.
• A skill standard library whose contracts propagate at compile. An invoke skill: step resolves against a versioned SkillLibrary (surface-embedding search with Jaccard fallback, Laplace-smoothed fitness ranking); the resolved skill’s outputSchema is adopted at compile so downstream in: ports type-check against the real contract. A recipe.compose RPC mechanically assembles a recipe from the top-ranked skill hits — the agent composes workflows from the library rather than re-deriving them in prose.
• Every failure is classified, not raw. A closed ErrorKind set — schema-mismatch, spawn-failure, timeout, budget-exceeded, guard-eval-error, sub-kit-failure, and more — drives the onError: policy router: retry (honored only for recoverable errors, clamped by a derived budget), fallback to a recovery recipe (depth-guarded to catch cycles), or continue-partial (a survivable failure is a recorded done-partial, not a crash). In a map/filter step, continue-partial drops failed elements and keeps aggregating survivors.
• All bounds are derived, never frozen. Re-dispatch budget, combinator fan-out, composition depth, and recovery-retry budget are each a small pure function of live signals — value-of-work, historical confidence, prior effort spent, and affordability — never a hardcoded constant. More structure at stake earns more correction attempts; a thin budget cuts them. A floored constant, where it appears at all, is a safety ceiling on a pathological derivation, never the working value.

Composable, not competing: how this fits the OSS ecosystem

BROCA shares a problem space with two notable open-source projects and a distribution registry. All three are treated as composable pieces the language folds in, not as alternatives to route around.