A Formal Hierarchical Architecture for Agentic Orchestration with Stack-Based Execution and Lazy Discovery

Jul 16, 2026

Large Language Model (LLM) agents face an architectural bottleneck when tool access is provided as a flat, monolithic registry: the model must score hundreds or thousands of options at once, causing decision-space explosion, context-window saturation, and degraded routing accuracy. The paper introduces a hierarchical, skill-based orchestration architecture that routes via a rooted tree, executes deterministic leaf tasks, and enforces a single-step LIFO stack loop with nested execution memory semantics. Capability discovery uses manifest-driven lazy loading to scale costs with the explored path. Isolation and auditability are ensured by localized stack frames, motivated by production deployment in UPI Help, and supported by formal state modeling, algorithmic analysis, and controlled benchmarks.

LanguageEnglish

CategoryResearch & Report

FormatPDF

Pages11

Reading Time28 min

Introduction

Limitation of flat capability spaces

Multiagent orchestration challenges

Need for deterministic execution control

Proposed hierarchical skill-based architecture

arXiv :2607 . 1 1 138v 1 [ cs .AI] 13 Jul 2026 A Formal Hierarchical Architecture for Agentic Orchestration with Stack-Based Execution and Lazy Discovery Prashant Devadiga, Abhishek, Adithya Mishra, Alok Singh, Amisha Sinha, Asit Desai, Gaurang Dahad, Harshit Bhushan, Mandati Pramod Reddy, Prakhar Gupta, Rupesh Patil, and Siddhi Behere Abstract—The rapid expansion of capabilities in Large Language Model (LLM) agents has exposed a critical architectural bottleneck: when agents are given access to a flat, monolithic registry of tools, the model must evaluate hundreds or thousands of options simultaneously. This leads to decision-space explosion, context window saturation, and degraded routing accuracy. To address these limitations, this paper presents a hierarchical, skill-based architecture for agentic orchestration. Capabilities are organized as a rooted tree where internal nodes make routing decisions and leaf nodes execute deterministic tasks. The runtime enforces a single-step execution loop governed by a Last-In-First-Out (LIFO) stack, giving the agent a form of memory akinto a Pushdown Automaton, therefore enabling it to track nested execution contexts and resume deterministically from any depth. Capability discovery follows a manifest-driven, lazy-loading protocol: only the immediate children of the active node are loaded, so memory and prompt costs scale with the explored path rather than the global registry. By replacing global memory with localized stack frames, the architecture prevents outputs from one execution branch from leaking into another, establishing the isolation guarantees required for deployment in regulated enterprise environments. We also discuss UPI Help, an AI-powered digital payments support product, as a motivating production deployment context. We provide a mathematical formalization of the orchestration state, detailed algorithmic analysis of the execution loop, and controlled benchmarks comparing flat and hierarchical routing under increasing tool catalogs, multi-step workflow pressure, and visible schema-token exposure per LLM call. ~~ ~~ ✦ ~~ ~~ 1 INTRODUCTION The integration of Large Language Models (LLMs) with external, deterministic capabilities (such as Application Programming Interfaces (APIs), database queries, and scripts) has enabled autonomous, goal-directed agents [2] . While early paradigms showed that interleaving reasoning with tool execution improves grounding and task completion, scaling these systems to enterprise-grade workflows exposes foundational architectural limitations [3] . The primary limitation of contemporary LLM agents is the assumption of a flat capability space. Conventional agents initialize with a registry containing all accessible tools [4] . At a scale encompassing hundreds or thousands of distinct capabilities, this induces decision-space explosion: the model must parse and choose among a large set of mostly irrelevant tools, increasing latency and degrading semantic routing accuracy [5] . Benchmarks confirm that large, nonhierarchical API arrays containing overlapping syntactic • Leadership: Prashant Devadiga. • Agentic Architecture: Abhishek, Alok Singh, Asit Desai, Gaurang Dahad, Harshit Bhushan, Prakhar Gupta. • Engineering: Adithya Mishra, Amisha Sinha, Mandati Pramod Reddy, Rupesh Patil, Siddhi Behere. • Evaluation: Abhishek, Gaurang Dahad, Harshit Bhushan. conventions increase reasoning failures and hallucinated tool invocations [6] . To distribute cognitive load, many systems adopt multiagent orchestration frameworks [7] . By deploying multiple specialized LLM agents that communicate via natural language, systems can theoretically tackle highly complex objectives [8] . However, these often rely on unstructured conversational message-passing for orchestration, which obscures execution state and makes routing and recovery difficult at scale, leading to unpredictable agent loops and network-wide context saturation [9] . In ad

FAQs

What problem does the paper identify with current LLM agent tool registries?

It identifies decision-space explosion and increased latency when agents must choose among large flat registries of mostly irrelevant tools, which also degrades semantic routing accuracy and increases failures.

How does the proposed architecture structure agent capabilities?

Capabilities are organized as a rooted tree of skills: internal nodes perform routing and delegation, while leaf nodes execute deterministic tasks.

How does stack-based execution and lazy discovery improve reliability and efficiency?

A single-step loop governed by a LIFO stack supports nested execution contexts and deterministic returns, while manifest-driven lazy loading loads only immediate children, reducing memory and prompt costs and preventing cross-branch output leakage.

Jul 16, 2026

Upload by Seraphina