Composable Signal Orchestration

• Composable signal orchestration is a framework that normalizes heterogeneous signals into reusable control primitives for dynamic decision-making and policy enforcement.
• It leverages Boolean algebra, decision trees, and plugin chains to compile complex routing rules while ensuring structural integrity and auditability.
• Empirical results show that demand-driven signal evaluation and modular design reduce latency and improve accuracy in multi-constraint deployment scenarios.

Composable signal orchestration denotes a systems and policy architecture in which heterogeneous signals derived from requests, responses, execution state, or infrastructure are normalized into reusable control primitives and then composed into routing, enforcement, and execution decisions. In the formulation introduced by the vLLM Semantic Router, a deployment is described by

$$\Gamma = (\mathcal{S}_\Gamma, \mathcal{D}_\Gamma, \Pi_\Gamma, \mathcal{E}_\Gamma),$$

separating active signal types, active decisions, attached plugin chains, and available endpoints; deployment behavior can then be changed by configuration alone, without code changes (Liu et al., 23 Feb 2026). Related orchestration work generalizes the same idea from per-request routing to control planes that manage planning, policy, execution, state, and quality operations over typed messages, tool calls, context objects, telemetry, and other control artifacts (Adimulam et al., 20 Jan 2026).

1. Formal definition and separations of concern

In its most explicit systems form, composable signal orchestration is organized around four distinct layers: signals, decision rules, routing policies, and model selection. The vLLM Semantic Router defines signals as typed facts or scores derived from a request, decisions as Boolean formulas over those signals, routing policies as the configured collection of decisions, plugin chains, and endpoints for one deployment, and model selection as the post-decision choice of a concrete model from the matched decision’s candidate pool. A decision is written as

$d = (n, \phi, \mathcal{M}_d, \Pi_d, p),$

with name, Boolean formula, candidate model set, plugin chain, and priority; the central systems claim is that orchestration happens before and around final model choice, rather than only at the last selection step (Liu et al., 23 Feb 2026).

This architecture was proposed as an answer to multi-constraint, policy-bearing deployments in which routing must jointly account for modality and domain, cost and latency, user role and authorization, privacy and safety policy, provider availability, multi-turn state, and response-side quality checks. The same policy orientation appears in declarative compilation work, where signals such as embedding similarity, PII detection, jailbreak scoring, keyword matching, authorization predicates, and complexity estimates are compiled into weighted projections, Signal_Groups, and priority-ordered Decision_Trees. Because that language is non-Turing-complete, the compiler guarantees exhaustive routing, dead branch detection, referential integrity, and structurally coupled audit traces, while also identifying a verification boundary: crisp predicates are fully decidable, geometric predicates are decidable under embedding-space assumptions, and classifier predicates remain opaque and empirically validated only (Chen et al., 28 Mar 2026).

2. Signal spaces and intermediate artifacts

The most detailed signal taxonomy currently appears in the vLLM Semantic Router, which specifies eleven built-in request-time signal types. A signal rule is

$\rho = (\tau, n, f),$

where $\tau$ is the signal type, $n$ a rule name, and

$f: \mathcal{R} \to \{0,1\} \times [0,1]$

maps a request to a binary match plus a confidence. The eleven types are divided into lightweight heuristic signals and learned signals. The heuristic group comprises keyword, context length, language, and authorization/role; the learned group comprises embedding similarity, domain classification, factual grounding, user feedback, modality detection, complexity, and preference. The paper further treats privacy and safety indicators, latency and TTFT or TPOT measurements, conversation state, provider or endpoint conditions, memory relevance gating, and retrieval scores as orchestration inputs beyond the canonical eleven (Liu et al., 23 Feb 2026).

Other orchestration systems broaden the meaning of “signal” beyond request features. In multi-agent control architectures, signals can include task assignments, intermediate outputs, telemetry, policy constraints, tool invocation requests, anomaly alerts, diagnostic reports, recovery triggers, and completion notifications (Adimulam et al., 20 Jan 2026). In modular RAG, ComposeRAG makes this especially explicit: question decomposition emits a planning signal, retrieval decision emits a binary control signal $d \in \{True, False\}$, answer verification emits a binary grounding signal $y \in \{True, False\}$, and self-reflection emits an analysis signal plus a revised decomposition artifact (Wu et al., 30 May 2025). AOrchestra defines an agent instance itself as a four-part tuple,

$\Phi = (I, C, T, M),$

where instruction, context, tools, and model function as runtime-instantiable orchestration fields for on-the-fly sub-agent creation (Ruan et al., 3 Feb 2026).

3. Composition mechanisms

In the vLLM formulation, heterogeneous signals are composed through a Boolean algebra. A decision expression tree is recursively defined by leaves of the form $\phi = leaf(\tau,n)$ and composite nodes $d = (n, \phi, \mathcal{M}_d, \Pi_d, p),$0 for $d = (n, \phi, \mathcal{M}_d, \Pi_d, p),$1; evaluation maps regex matches, authorization roles, classifier outputs, and embedding thresholds into the same decision language. If multiple decisions match, resolution is either priority-based or confidence-based, with priority as the default production mode for determinism. The system is therefore parallel in signal extraction, threshold-based at many leaves, Boolean in policy composition, priority-ordered or confidence-ranked at decision resolution, sequential in plugin execution, hierarchical because decisions first narrow candidate pools and only then invoke a selector, and plugin-driven for enforcement and transformations (Liu et al., 23 Feb 2026).

Declarative policy compilation develops a complementary account of composition. Signal scores may first pass through weighted projections; Signal_Groups apply temperature-scaled softmax normalization to control co-firing; and decision trees then impose first-match semantics. The paper cites a condition from prior work stating that with threshold $d = (n, \phi, \mathcal{M}_d, \Pi_d, p),$2 and temperature $d = (n, \phi, \mathcal{M}_d, \Pi_d, p),$3, at most one of the $d = (n, \phi, \mathcal{M}_d, \Pi_d, p),$4 grouped signals fires. The same source policy can then be lowered into inference gateways, LangGraph nodes, OpenClaw hooks, Kubernetes artifacts, MCP gates, A2A gates, and YANG or NETCONF payloads, so composition occurs both within a decision function and across operational layers (Chen et al., 28 Mar 2026).

A longer historical lineage appears in synchronous reactive orchestration. HipHop, embedded in Hop, models logical events with presence or absence semantics, repeated atomic reactions, and combinators such as seq&, par&, pause&, trap&, exit&, abort&, until&, and local&. Emission, waiting, suspension, and preemption are therefore expressed as compositions of logical signals rather than ad hoc asynchronous callbacks (Berry et al., 2013). This suggests that composable signal orchestration includes both policy algebra over heterogeneous detectors and event calculus over logical time.

4. End-to-end orchestration and policy enforcement

Composable signal orchestration is not confined to a pre-routing classifier. In the vLLM router, the request path proceeds through API translation, request parsing and provider detection, parallel and lazy signal extraction, decision evaluation, a pre-routing plugin chain, semantic model selection, and endpoint resolution. The pre-routing plugin chain is ordered as jailbreak, PII, cache lookup, RAG injection, modality routing, memory retrieval, system prompt injection, and header mutation. The response path then performs token usage extraction, provider-to-OpenAI translation, streaming metrics extraction, HaluGate hallucination analysis, semantic cache write, and optional Responses API wrapping. Safety and privacy are scoped per decision rather than globally: jailbreak thresholds, PII allow or deny policies, caching, on-prem-only model pools, and hallucination actions can differ across healthcare, public-facing, cost-optimized, or multi-turn deployments. The three-stage HaluGate pipeline consists of Sentinel, Detector, and Explainer; Sentinel classifies 40–60% of queries as non-factual, allowing later verification stages to be skipped (Liu et al., 23 Feb 2026).

Cross-layer orchestration research extends the same logic to protocol boundaries and workflow nodes. Declarative policy compilation emits verified decision nodes for LangGraph and OpenClaw, as well as MCP and A2A gate functions, Kubernetes NetworkPolicy and ConfigMap artifacts, and YANG or NETCONF payloads from one policy source (Chen et al., 28 Mar 2026). In parallel, multi-agent orchestration frameworks distinguish MCP as the client-server protocol for tools, resources, prompts, and contextual repositories, and A2A as the peer protocol for delegation, negotiation, intermediate-result exchange, diagnostics, and recovery status (Adimulam et al., 20 Jan 2026). A plausible implication is that composable signal orchestration increasingly functions as a cross-layer control plane rather than as a single runtime router.

5. Architectural variants beyond inference routing

Several recent systems instantiate the same organizing idea in different forms. AgenticScholar translates natural-language queries into executable DAG plans over a structured scholarly graph, using a Scope/Task decomposition, predefined plan selection, dynamic plan generation, validation, self-correction, and a unified execution layer with composable operators such as Search, Traverse, Retrieve, Extract, Summarize, Verify, Rank, GroupBy, Aggregate, Filter, Generate, and MatrixConstruct. Its execution_mode parameter distinguishes instance from group, and the runtime unfolds compact logical plans into data-aware DAGs after scope evaluation (Lan et al., 14 Mar 2026).

For multi-agent learning, orchestration traces have been proposed as the primary object of analysis. In that view, a trace is a typed temporal interaction graph

$d = (n, \phi, \mathcal{M}_d, \Pi_d, p),$5

whose events include spawn, message, tool call, tool result, return, aggregate, human intervention, and safety events. Reward design spans eight families, credit can attach at eight levels from team to token, and orchestration learning decomposes into five sub-decisions: when to spawn, whom to delegate to, how to communicate, how to aggregate, and when to stop; the curated pool reported in that survey found no explicit RL training method for the stopping decision (Zhang, 4 May 2026).

Executable orchestration synthesis appears in two further systems. AOrchestra restricts the orchestrator’s action space to

$d = (n, \phi, \mathcal{M}_d, \Pi_d, p),$6

so the controller only delegates sub-agents or terminates, never directly takes environment actions (Ruan et al., 3 Feb 2026). LEMON instead generates a YAML orchestration specification whose fields determine task-specific roles, customized duties, capacity levels, and dependencies, compiles it into a layered DAG, and trains it with orchestration-level GRPO plus localized counterfactual edits over role, capacity, and dependency spans (Chen et al., 14 May 2026). This suggests that the topic now spans both runtime routing systems and learned generation of executable control artifacts.

6. Empirical evidence, benefits, and limitations

The strongest current evidence is systems-oriented. In the vLLM router, heuristic signals run in sub-ms to less than 1 ms, while learned signals occupy the 10–120 ms range; on A100 plus ModernBERT, embedding has median 15 ms and p99 45 ms, domain median 60 ms and p99 120 ms, fact-check median 55 ms and p99 110 ms, modality median 50 ms and p99 100 ms, and complexity, preference, and feedback about 50–55 ms median. Demand-driven evaluation with only 3–5 active signal types out of 11 reduces total signal extraction latency by 50–70% versus exhaustive evaluation. Decision evaluation itself costs less than 0.1 ms for 10 decisions times 3 conditions and less than 0.5 ms for 100 decisions times 5 conditions. The same paper reports 100% exact-match semantic-cache hit rate, 60–80% paraphrase hit rate, and lookup latency below 5 ms at similarity threshold $d = (n, \phi, \mathcal{M}_d, \Pi_d, p),$7; for six tasks, independent models require 3438 MB while the LoRA architecture uses 575 MB (Liu et al., 23 Feb 2026).

Comparable evidence appears in other orchestration settings. AgenticScholar reports that enabling predefined plan selection reduces planning input and output tokens and planning time by more than 90%, and its self-correction loop solves 62.5% of complex Tier-2 queries with no repair and 100% within three repairs (Lan et al., 14 Mar 2026). ComposeRAG reports up to a 15% accuracy improvement over fine-tuning-based methods and up to a 5% gain over reasoning-specialized pipelines under identical retrieval conditions, while its verification-first design reduces ungrounded answers by over 10% in low-quality retrieval settings and by approximately 3% with strong corpora (Wu et al., 30 May 2025). AOrchestra reports a 16.28% relative improvement against the strongest baseline when paired with Gemini-3-Flash (Ruan et al., 3 Feb 2026), and LEMON reports state-of-the-art performance among the evaluated multi-agent orchestration methods on six reasoning and coding benchmarks (Chen et al., 14 May 2026).

Several limits recur across the literature. Composable signal orchestration is not equivalent to a monolithic classifier or a simple message bus; role-based compliance, per-decision no-cache rules, protocol-boundary gates, and backend-auth heterogeneity are exactly the cases cited as poorly expressed by monolithic routing approaches (Liu et al., 23 Feb 2026). Verification guarantees also stop at specific boundaries: declarative compilation can guarantee exhaustive routing and structural audit consistency, but not classifier correctness, workflow sequencing outside policy checkpoints, tool correctness, or prompt correctness (Chen et al., 28 Mar 2026). In orchestration-trace RL, explicit counterfactual message-level credit remains sparse and no explicit RL training method for stopping was found in the curated pool (Zhang, 4 May 2026). The field therefore supports a precise but bounded conclusion: composable signal orchestration is now a recognizable control-plane pattern, but its strongest guarantees remain structural, policy-level, and systems-level rather than fully semantic or end-to-end.