Paper deep dive
Polaris : Multi Agentic System for Conversational Enterprise Analytics
Varuni H K, Soham Sarkar, Jay Kumar, Goutham Krishnan, Tanvi Johari, Avinash Bharadwaj, Santosh Hegde
Intelligence
Status: succeeded | Model: Gemma-4-26B-A4B | Prompt: intel-v1 | Confidence: 92%
Last extracted: 8/17/2026, 5:22:15 AM
Summary
The paper introduces Polaris, a supervisor-led multi-agent framework for conversational enterprise analytics. It utilizes Dynamic Task Coordination (DTC), modeled as adaptive bipartite matching, to orchestrate specialized agents (Query, Visualization, Reasoning, Report) that process natural language queries into SQL++, generate visualizations, and provide causal explanations. Evaluated on the Airbnb dataset, Polaris demonstrates high semantic fidelity and answer relevancy.
Entities (11)
Relation Signals (10)
Polaris → evaluatedon → Airbnb listings dataset
confidence 95% · We evaluate Polaris on the Airbnb listings dataset
Query Expert → generates → SQL
confidence 95% · translating ambiguous natural language into precise, executable queries in SQL++
Polaris → uses → Dynamic Task Coordination
confidence 95% · Polaris introduces Dynamic Task Coordination (DTC), a decision-theoretic orchestration layer
Polaris → contains → Reasoning Expert
confidence 90% · Polaris employs a dedicated Reasoning Expert to interpret query results
Polaris → contains → Report Expert
confidence 90% · The Report Expert compiles insights, visualizations, and contextual information into structured reports
Polaris → contains → Charting Expert
confidence 90% · The Charting Expert is responsible for transforming structured query outputs into visual representations
Polaris → contains → Supervisor Agent
confidence 90% · The Supervisor Agent is the main controller of the system
Polaris → contains → Query Expert
confidence 90% · The Query Expert addresses one of the hardest gaps in conversational data intelligence
Cypher Suggestions (0)
No Cypher suggestions yet.
Abstract
Abstract:In today's fast-paced environment, the ability to swiftly access, understand, and act on data is no longer optional; it is essential. Yet most organizations remain data-rich but insight-poor, constrained by the complexity of querying, interpreting, and explaining enterprise-scale information. We present Polaris, a supervisor-led multi-agent framework for conversational enterprise analytics that bridges this gap. Polaris introduces Dynamic Task Coordination (DTC), a decision-theoretic orchestration layer that models agent-task assignment as adaptive bipartite matching, enabling real-time coordination, recovery, and optimization across specialized agents for querying, visualization, and reasoning. By coupling DTC with reason-first, ReAct-style agents, Polaris transforms natural-language queries into coherent analytical workflows that not only retrieve and visualize data but also explain the underlying "why." Evaluation on structured enterprise datasets demonstrates high semantic fidelity and answer relevancy, underscoring the potential of multi-agent orchestration to deliver trustworthy, end-to-end business intelligence at scale.
Tags
Links
- Source: https://arxiv.org/abs/2608.14246v1
- Canonical: https://arxiv.org/abs/2608.14246v1
Trouble viewing inline? Open PDF directly →
Full Text
18,579 characters extracted from source content.
Expand or collapse full text
Polaris : Multi Agentic System for Conversational Enterprise Analytics Varuni H K Soham Sarkar Jay Kumar Goutham Krishnan Tanvi Johari Avinash Bharadwaj Santosh Hegde Abstract In today’s fast-paced environment, the ability to swiftly access, understand, and act on data is no longer optional, it is essential. Yet most organizations remain data-rich but insight-poor, constrained by the complexity of querying, interpreting, and explaining enterprise-scale information. We present Polaris, a supervisor-led multi-agent framework for conversational enterprise analytics that bridges this gap. Polaris introduces Dynamic Task Coordination (DTC), a decision-theoretic orchestration layer that models agent–task assignment as adaptive bipartite matching, enabling real-time coordination, recovery, and optimization across specialized agents for querying, visualization, and reasoning. By coupling DTC with reason-first, ReAct-style agents, Polaris transforms natural language queries into coherent analytical workflows that not only retrieve and visualize data but also explain the underlying “why.” Evaluation on structured enterprise datasets demonstrates high semantic fidelity and answer relevancy, underscoring the potential of multi-agent orchestration to deliver trustworthy, end-to-end business intelligence at scale. Introduction The proliferation of large-scale enterprise data repositories has created unprecedented opportunities for data-driven decision making, yet the complexity of extracting actionable insights from heterogeneous data sources remains a fundamental bottleneck in organizational intelligence systems. Traditional approaches to enterprise data analytics rely heavily on domain expertise in query languages, schema understanding, and statistical interpretation, creating significant barriers to widespread adoption and limiting the democratization of data-driven insights across organizational hierarchies. Large language models (LLMs) enable natural language interaction, but most systems rely on single agents that struggle with compositional reasoning, multi-step coordination, and session-level coherence (10; 14). These limits are acute in enterprise settings that require query generation, statistical analysis, visualization, and narrative explanation. Multi-Agent Systems (MAS) decompose complex tasks into coordinated components and can outperform single agents in tool use and long-horizon planning (8; 9; 13; 3; 15). Yet MAS for enterprise analytics remains relatively underexplored, especially adaptive coordination that optimizes task allocation and enables intelligent error recovery in conversational workflows. We propose a supervisor-led MAS framework with Dynamic Task Coordination (DTC): Dynamic Task Coordination (DTC), a decision-theoretic, online orchestration layer for conversational data analytics. DTC models coordination as adaptive bipartite matching on G=(A∪T,E)G=(A∪ T,E), where each agent a∈Aa∈ A has a capability vector a θ_a and each task t∈Tt∈ T has a descriptor t τ_t. Edge utilities combine capability fit, and empirical reliability: U(a,t∣s)=αsim(a,t)+βq(a,t)−γc(a,t)U(a,t s)=α\,sim( θ_a, τ_t)+β\,q(a,t)-γ\,c(a,t), given state s. We formalize matching as: M∗=argmax∑(a,t)∈M∈ℳU(a,t∣s)M^*= _M _(a,t)∈ MU(a,t s) (1) Here, M∗M^* denotes the optimal feasible matching (the selected set of agent–task pairs), and argmax indicates choosing, among all feasible M∈ℳM , the one that maximizes the total utility. This decision-theoretic formulation maximizes capability fit and empirical reliability while penalizing cost, yielding principled allocations under constraints. ℳM denotes feasible matchings under precedence, capacity, and tool/data-availability constraints. Execution feedback (diagnostic traces, errors, latencies) updates q(a,t)q(a,t) and the belief over a θ_a, enabling uncertainty-aware re-planning, preemption, and rollback. This yields real-time constraint satisfaction, adaptive load balancing, and capability-aware assignment across heterogeneous agents. Our framework seamlessly integrates structured data analysis, dynamic visualization generation, and causal reasoning within a unified conversational interface. This multi-modal approach addresses the critical gap between data presentation and explanatory understanding that limits the effectiveness of existing business intelligence systems. Proposed Work At its core, Polaris employs a network of specialized agents coordinated through our Dynamic Task Coordination (DTC) framework. Concretely, the supervisor solves the matching problem in Eq. 1 as user goals, tool latencies, and data availability evolve. This centralized coordination maintains persistent state across sessions, orchestrates sub-tasks via capability-aware matching, and enforces semantic alignment between multi-modal outputs (e.g., ensuring visualizations, query results, and narratives remain coherent). Figure 1: Architecture and Decision Flow for Polaris All agents in Polaris adopt a reason-first approach within the DTC coordination paradigm, where contextual reasoning precedes tool selection and execution, following a ReAct (Reasoning + Action) framework (15; 7; 6). By interleaving chain-of-thought reasoning with concrete actions in adaptive thought–action–observation loops, agents can intelligently plan multi-step workflows, dynamically adapt to intermediate outcomes and system constraints, and produce coherent, context-aware insights while maintaining optimal resource utilization through DTC optimization. Orchestration and Understanding: Supervisor Agent The Supervisor Agent is the main controller of the system and implements DTC end-to-end: it parses intent, maintains context, and routes tasks by approximately solving Eq. 1 under precedence and capacity constraints (5; 4). It decomposes ambiguous requests into concerete workflows (e.g., causal analysis, trend comparisons, multi-dimensional reporting). Real-time diagnostics update q(a,t)q(a,t) and constraints, enabling re-matching, rollback, or alternative tool selection. Upon schema mismatches or missing fields, the Supervisor triggers recovery protocols, proposes semantically equivalent alternatives, and preserves conversational continuity. Data Retrieval and Transformation The Query Expert addresses one of the hardest gaps in conversational data intelligence: translating ambiguous natural language into precise, executable queries in SQL++ (2). Its operation begins with schema inference and annotation, where it not only identifies fields and datatypes through the SQL++ INFER command but also grounds them in semantic annotations. This disambiguation is crucial, what looks like a generic field such as ”amount” can be resolved into ”total sales amount” when the context demands it, ensuring queries are aligned with enterprise-specific semantics rather than surface-level matches. Next, through input canonicalization, vague user prompts are expanded into explicit task statements, enabling the system to bridge the mismatch between colloquial phrasing (“sales last month”) and the structured detail required for query generation. Once canonicalized, the request undergoes NL-to-SQL++ translation, where reasoning steps are intertwined with tool calls rather than separated, following a reason-first ReAct approach (15). Finally, the Query Expert performs data quality checks and adaptive recovery: it detects null-heavy columns, schema mismatches, or overlarge results, and autonomously reformulates queries. In cases where the output would exceed LLM context limits, the agent shifts to adaptive aggregation, summarizing distributions without sacrificing fidelity to trends and anomalies. The contribution of this design is subtle but significant: by combining semantic annotation, canonicalization, and reasoning-driven aggregation, the Query Expert ensures that data retrieval is not just syntactically correct but contextually faithful and resilient to the imperfections of real-world enterprise data. Visualization and Insights: Charting Expert The Charting Expert is responsible for transforming structured query outputs into visual representations that facilitate data interpretation. Unlike conventional systems that rely on predefined templates, it uses a combination of rule-based heuristics and the ReAct framework to determine the most suitable visualization type based on the structure and semantics of the retrieved data. For example, temporal sequences are represented using line charts to emphasize trends over time, whereas categorical comparisons are rendered as bar or pie charts to highlight distributional contrasts. The Charting Expert generates executable visualization code dynamically, primarily using the Seaborn and Plotly libraries. The agent has access to a Python REPL environment, where the generated code is executed, and the resulting output or error stack trace is returned as structured feedback. This enables automatic error detection and self-correction—if a visualization fails due to syntax or data-related issues, the agent refactors the code or alters the chart type and re-executes it without human intervention. The combination of reasoning-guided chart selection, dynamic code synthesis, and feedback-driven refinement yields a visualization pipeline that is adaptive, self-correcting, and semantically aligned with both the data and the user’s intent. Explanation and Reasoning Beyond visualization, Polaris employs a dedicated Reasoning Expert to interpret query results and provide detailed insights. This agent leverages LLM to uncover latent patterns, identify causal relationships, and generate explanatory narratives, that go beyond descriptive summaries. Reasoning is further augmented with domain-specific knowledge extracted from the user’s database, allowing the system to produce explanations that are both contextually grounded and logically coherent (12; 11). Summarizing and Report Generation The Report Expert compiles insights, visualizations, and contextual information into structured reports. It aggregates content by summarizing query results, embedding visualizations, documenting methodologies, and incorporating metadata such as data sources and query parameters. Results We evaluate Polaris on the Airbnb listings dataset(1), which contains structured metadata about rental properties across New York. To ensure systematic and reproducible evaluation, we employed a synthetic data generator to construct a golden dataset consisting of 40 query–answer pairs. Each instance comprises: (1) a natural language query, (2) a reference answer derived from the dataset, (3) the ground truth context used to generate the answer, (4) the retrieved context produced by our NL2SQL++ pipeline, and (5) the final agent response. Evaluation Metrics Semantic Similarity. Semantic similarity measures the embedding-level similarity between retrieved context crc_r and ground truth context cgc_g, computed using cosine similarity: SemanticSimilarity(cr,cg)=⟨(cr),(cg)⟩‖(cr)‖‖(cg)‖SemanticSimilarity(c_r,c_g)= (c_r),e(c_g) \|e(c_r)\|\,\|e(c_g)\| (2) where (⋅)e(·) denotes the embedding function. Context Precision. Context precision quantifies the proportion of retrieved contexts that are relevant relative to the ground truth: ContextPrecision=|Cr∩Cg||Cr|ContextPrecision= |C_r∩ C_g||C_r| (3) where CrC_r is the set of retrieved contexts and CgC_g is the set of ground truth contexts. Answer Relevancy. Answer relevancy evaluates whether the generated answer a is relevant to both the query q and the retrieved context CrC_r: AnswerRelevancy(a,q,Cr) (a,q,C_r) =λsim((a),(q)) =λ\,sim(e(a),e(q)) (4) +(1−λ)sim((a),(Cr)) +(1-λ)\,sim(e(a),e(C_r)) where λ∈[0,1]λ∈[0,1] balances query alignment and context faithfulness. Interpretation The aggregated results across all 40 evaluation instances are summarized in Table 1. Our system achieved high average scores across all metrics: semantic similarity (0.85), context precision (0.99), and answer relevancy (0.90). Table 1: Average metric scores across 40 evaluation samples. Metric Average Score Model Semantic Similarity 0.85 GPT-4o Context Precision 0.99 GPT-4o Answer Relevancy 0.90 GPT-4o To further analyze robustness, we evaluate the percentage of samples exceeding predefined metric thresholds (Table 2). Our framework demonstrated consistent precision and reliability, with 100% of samples surpassing thresholds for semantic similarity and context precision, and 92.5% surpassing the answer relevancy threshold. Table 2: Threshold-based evaluation of metric quality. Metric Threshold Above (%) Semantic Similarity 0.70 100.0 Context Precision 0.90 100.0 Answer Relevancy 0.70 92.5 These results highlight two key findings. First, the NL2SQL++ module reliably captured user intent and generated precise SQL queries, as evidenced by perfect scores in semantic similarity and context precision. Second, while answer relevancy achieved a strong 92.5% success rate, a small number of responses fell below the threshold. We attribute this variance to the generative nature of large language models, which may introduce stylistic or explanatory deviations even when grounded in correct evidence. Importantly, these deviations did not significantly degrade overall answer quality, underscoring the robustness of Polaris’s multi-agent design for conversational enterprise analytics. Future Work and Conclusion We identify several directions to strengthen Polaris beyond the current implementation: • Adaptive orchestration with learned utility models and long term agent memeory that personalize U(a,t∣s)U(a,t s) per organization and user. • Integrating with a global data catalog to ensure consistent and meaningful annotations across varied columns to maintain the quality of insights generated by AI agents. • Workflows with editable plans, sandboxes for dry runs, and assisted what-if analyses. We introduced Polaris, a supervisor-based multi-agent framework for conversational enterprise analytics centered on Dynamic Task Coordination. By formalizing orchestration as adaptive bipartite matching and coupling it with reason-first agents for querying, visualization, and explanation, the system executes coherent multi-step workflows with strong grounding. Our evaluation shows high semantic similarity and context precision, indicating faithful retrieval and reliable answer generation. These results suggest that principled orchestration is a promising path toward reliable, auditable, and efficient enterprise analytics at scale. References Azmoudeh (2021) A. Azmoudeh Airbnb open data. Note: KaggleDataset available at https://w.kaggle.com/datasets/arianazmoudeh/airbnbopendata Cited by: Results. Carey et al. (2024) M. Carey, D. Chamberlin, A. Goo, K. W. Ong, Y. Papakonstantinou, C. Suver, S. Vemulapalli, and T. Westmann SQL++: we can finally relax!. In 2024 IEEE 40th International Conference on Data Engineering (ICDE), Vol. , p. 5501–5510. External Links: Document Cited by: Data Retrieval and Transformation. Hong et al. (2023) S. Hong, X. Zheng, J. Chen, Y. Cheng, C. Zhang, Z. Wang, S. K. S. Yau, Z. Lin, L. Zhou, C. Ran, et al. MetaGPT: meta programming for a multi-agent collaborative framework. In The Twelfth International Conference on Learning Representations, Cited by: Introduction. Karp et al. (1990) R. M. Karp, U. V. Vazirani, and V. V. Vazirani An optimal algorithm for on-line bipartite matching. In Proceedings of the Twenty-second Annual ACM Symposium on Theory of Computing, Cited by: Orchestration and Understanding: Supervisor Agent. Kuhn (1955) H. W. Kuhn The hungarian method for the assignment problem. Naval Research Logistics Quarterly 2, p. 83–97. Cited by: Orchestration and Understanding: Supervisor Agent. Schick et al. (2023) T. Schick, J. Dwivedi-Yu, H. Sch”utze, et al. Toolformer: language models can teach themselves to use tools. arXiv preprint arXiv:2302.04761. Cited by: Proposed Work. Shen et al. (2023) Y. Shen, K. Song, X. Tan, D. Jiang, et al. HuggingGPT: solving ai tasks with chatgpt and its friends in huggingface. arXiv preprint arXiv:2303.17580. Cited by: Proposed Work. Stone and Veloso (2000) P. Stone and M. Veloso Multiagent systems: a modern approach to distributed artificial intelligence. MIT Press, Cambridge, MA. Cited by: Introduction. Tampuu et al. (2017) A. Tampuu, T. Matiisen, D. Kodelja, I. Kuzovkin, K. Korjus, J. Aru, J. Aru, and R. Vicente Multiagent deep reinforcement learning with extremely sparse rewards. arXiv preprint arXiv:1707.01495. Cited by: Introduction. Wang et al. (2023a) L. Wang, C. Ma, X. Feng, Z. Zhang, H. Yang, J. Zhang, Z. Chen, J. Tang, X. Chen, Y. Lin, et al. A survey on large language model based autonomous agents. arXiv preprint arXiv:2308.11432. Cited by: Introduction. Wang et al. (2023b) X. Wang, J. Wei, D. Schuurmans, Q. Le, E. Chi, S. Narang, A. Chowdhery, and D. Zhou Self-consistency improves chain of thought reasoning in language models. In International Conference on Learning Representations, Cited by: Explanation and Reasoning. Wei et al. (2022) J. Wei, X. Wang, D. Schuurmans, M. Bosma, B. Ichter, et al. Chain-of-thought prompting elicits reasoning in large language models. arXiv preprint arXiv:2201.11903. Cited by: Explanation and Reasoning. Wu et al. (2023) Q. Wu, G. Bansal, J. Zhang, Y. Wu, S. Zhang, E. Zhu, B. Li, L. Jiang, X. Zhang, and C. Wang AutoGen: enabling next-gen llm applications via multi-agent conversation. In Proceedings of the International Conference on Machine Learning, Cited by: Introduction. Xi et al. (2023) Z. Xi, W. Chen, X. Guo, W. He, Y. Ding, B. Hong, M. Zhang, J. Wang, S. Jin, E. Zhou, et al. The rise and potential of large language model based agents: a survey. arXiv preprint arXiv:2309.07864. Cited by: Introduction. Yao et al. (2023) S. Yao, J. Zhao, D. Yu, N. Du, I. Shafran, K. Narasimhan, and Y. Cao ReAct: Synergizing Reasoning and Acting in Language Models. arXiv e-prints. Note: Published in ICLR 2023 External Links: 2210.03629v3 Cited by: Introduction, Data Retrieval and Transformation, Proposed Work.