Trust-Aware Orchestration Architecture for LLM-Assisted Workflows in Multi-Tenant Enterprise Systems
Authors’ abstract
Large language models (LLMs) now call tools and APIs in enterprise systems, creating concrete risks: hallucinated parameters, cross-tenant data leakage, and prompt injection. This paper presents an orchestration architecture for multi-tenant deployments where the LLM proposes actions and a deterministic control plane validates and executes them, organized as three hard enforcement gates (authentication and tenant resolution, role-based tool authorization, and schema validation), four advisory filters (input sanitization, retrieval scoping, execution monitoring, output compliance), and append-only audit logging. The hard gates provide three structural guarantees (tenant isolation, tool-allowlist enforcement, schema conformance) specified as deterministic predicates and verified at the logical control-plane level; they do not defend against within-scope intent manipulation, in which an authorized role invokes an authorized tool with schema-valid parameters for a malicious purpose. A 20-prompt adaptive case study shows within-scope attacks succeed on every one of five LLMs tested, at point-estimate rates of 30%–70%, including the three frontier Claude models (Haiku 4.5, Sonnet 4, Opus 4.6). The structural guarantees hold uniformly across 14,885 evaluations: 1,497 custom prompts plus adversarial prompts from two established benchmarks (683 TensorTrust and 777 AgentDojo across three domains and three attack strategies) and a 20-prompt adaptive case study. Targeted attack-success rate on AgentDojo is ≤ 1.9% across all five models, comparable to published defended baselines. Deterministic syntax recovery reduces the 3B model’s false rejection rate from 52% to 15.2% at zero latency cost; frontier models achieve 0%. Input sanitization flagged injection patterns in only 10.2% of injection prompts without solo-rejecting any, confirming pattern-based detection is insufficient. Within-scope intent manipulation remains an open problem the hard gates do not address. The architecture targets enterprise systems requiring explainability, safety, and regulatory compliance. INDEX TERMS Large language models, trust-aware systems, orchestration architecture, multi-tenant systems, retrieval-augmented generation, schema validation, AI governance, guardrails, enterprise AI safety. I. INTRODUCTION Large language models are no longer just chat interfaces. They now call tools, query databases, and trigger API actions inside enterprise software [4], [51]. Advances in tool invocation [2], [3], retrieval-augmented generation [12], and agent-based reasoning [1] have made this practical. An LLM can look up a customer record, create an invoice, or initiate a fund transfer, all from a natural language prompt. The associate editor coordinating the review of this manuscript and approving it for publication was Jonathan Rodriguez. The problem is that LLMs are probabilistic. They generate outputs based on statistical patterns, not deterministic rules. A model can hallucinate wrong parameters for an API call (e.g., transferring $10,000 instead of $100), or generate a call to a tool that does not exist [52]. When the model interacts with real tools and databases, these errors have real consequences [25], [29]. In multi-tenant platforms (where multiple organizations share a single orchestration layer), one cross-tenant data leak or one unauthorized tool call creates compliance exposure. Multi-tenant data centers already struggle with traffic separation [46], and shared data services add elasticity and cost-sharing challenges [48]. Adding an LLM that can reach across tenant boundaries makes things worse. Existing defenses focus on prompt engineering, output filtering, or model alignment [24], [27]. These help, but they are not enough for regulated enterprises that need hard guar-antees on correctness, access control, and auditability. In most deployed systems today, the LLM is the implicit authority: its output flows directly to tool execution with minimal validation. This makes it difficult to enforce deterministic behavior, trace decision paths, or prevent unsafe tool calls. The core argument of this paper is straightforward: you cannot make an LLM trustworthy by making it smarter. Trust must be established at the architecture level. The term ‘‘trust-aware’’ here means three things: (1) trust is quantified via per-layer scoring, (2) trust boundaries are enforced through deterministic gates, and (3) trust provenance is maintained through immutable audit trails. This is different from ‘‘trustworthy AI’’ frameworks [43], [44] that focus on model-level properties like fairness and robustness. The focus here is on architectural mechanisms that make the system trustworthy regardless of how the model behaves. The LLM should be an advisor. It proposes; the system decides. This paper presents such an architecture for multi-tenant enterprise systems. It combines deterministic orchestration, tenant-isolated retrieval, schema-validated tool execution, role-based policy enforcement, and a guardrail pipeline organized as three hard gates (authentication and tenant reso-lution, policy and tool authorization, and schema validation), together with four advisory filters (input sanitization, retrieval scoping, execution monitoring, and output compliance). The hard gates carry the load-bearing security guarantees and produce binary pass/fail decisions; the advisory filters contribute heuristic signals to a per-request trust score and address threats the hard gates do not target directly. The core enforcement mechanisms are specified as deterministic predicates and validated through simulation and empirical testing. To make this concrete early: Section IX walks through two end-to-end scenarios (a valid tool invocation and a prompt injection attempt), showing how each pipeline layer processes the request. The individual enforcement mechanisms (role-based access control [RBAC], schema validation, tenant scoping, audit logging) are established. What is missing is a mandatory composition that no LLM output can bypass, and data on what actually happens when real models run inside it. The contributions are:
Paper
- Authors
- N. Leburu
- Publication date
- 2026
Transcript
A transcript has not been published for this episode yet.
Licensing
- Source license
- Creative Commons Attribution 4.0 International
- Recording license
- CC-BY-4.0
The authors and publisher do not sponsor or endorse this recording.