AI Pilots: Predicting Flight Delays Using Multi-Persona Agents and Distributed Data

The modern enterprise seeks intelligent, adaptive systems capable of sophisticated planning, context-aware decision-making, and leveraging massive real-world data. This blog describes an example that achieves this by combining agentic AI using Embabel and Spring AI with the power of semantic and structural queries using YugabyteDB as the backbone, while applying enterprise Java best practices to predict flight delays in a robust, scalable manner. While this implementation doesn’t include all necessary production parameters, it encompasses an indicative workflow that showcases how to build enterprise-grade GenAI applications using proven enterprise frameworks and database infrastructure for the Java ecosystem.

The Case for Agentic AI in Enterprise Java

Java remains the gold standard for enterprise applications. Its stability, performance, and extensive ecosystem have been proven in mission-critical workloads.

Stability and Scalability: Java’s extensive ecosystem and strict typing have long served as the foundation for large-scale, mission-critical applications.

Robust Tooling: Enterprise-grade libraries, mature frameworks, and strong ecosystem enable complex workflows and reliable integration touchpoints.

Performance: JVM optimizations and multi-threading capabilities deliver fast processing, even with heavy data and compute loads.

However, static workflows and traditional coding paradigms struggle with real-world complexity. Agentic AI addresses this challenge by imbuing software agents with flexible, goal-directed behavior, enabling applications to adapt to changing information and dynamic environments.

Embabel: Goal-Oriented Action Planning for Real Intelligence

Embabel allows developers to orchestrate AI agents whose actions are determined not by static sequences, but by the optimal pathway to achieve mission goals.

Agentic AI via GOAP: Embabel introduces Goal-Oriented Action Planning for Java and Kotlin, empowering agents to dynamically plan and solve real tasks.

Agent Flows: Your business logic becomes intelligent and adaptable as agents model domain-specific actions, goals, and conditions rather than simply adhering to static rules. You define goals (what you want to accomplish), actions (available steps), and conditions/preconditions/effects (when actions can be performed and what state they require/produce). Embabel employs a planner (a non-LLM algorithm) to create plans (sequences of actions) that use domain models to achieve a goal.

Strong Typing & Planning: Compile-time safety guarantees reliable code, while flexible planning allows agents to handle new tasks without explicit programming.

Integration with Spring: Seamless integration ensures that typical enterprise setups feel natural.

Rather than following hardcoded business rules, Embabel agents pursue goals (e.g., “Predict delay for Flight X”), considering available actions, the current world state, and learned strategies.

Spring AI: Enterprise-Ready Generative Intelligence

Spring AI, from the Spring ecosystem brings generative AI, vector search, memory, tool calling, and more into the Spring world. It provides structured abstractions for working with LLMs, prompt engineering, observability, and beyond.

Unified AI Integration: A robust, developer-friendly framework that enables easy access to AI models, document readers, and vector stores, saving developers time and complexity.

Enterprise-Ready: Built for businesses, Spring AI provides dependency injection, robust security, and easy customization.

Spring AI supports and enables: ✓ RAG (retrieval augmented generation) workflows ✓ Integration with vector stores for embeddings and similarity search ✓ Structured output formats, guardrails, and tool calling ✓ Composition of AI workflows/agents in predictable, testable ways

YugabyteDB: The Distributed Data backbone

Distributed SQL & Resilience: YugabyteDB’s cloud-native architecture delivers high availability and horizontal scalability for critical, real-time agentic tasks.

PostgreSQL Compatibility: Use familiar drivers and libraries to increase developer productivity and ensure portability of existing tools and workflows.

Support for Vector Embeddings: The pgvector extension stores and searches AI vector embeddings directly within the database for fast retrieval. AI solutions can perform vector search and similarity queries natively, powering RAG and other advanced AI workflows.

Hybrid AI-Driven Workflows: The synergy of semantic and structural queries enables agents to combine contextual wisdom (from embeddings) with business rules and filters, all in real time.

Enterprise Features: From controlled scaling and robust security to GDPR compliance and seamless operation, YugabyteDB serves as a comprehensive data platform for global, high-throughput applications.

Getting Started

Prerequisites: • Java 21+, Maven • YugabyteDB • Docker

Quick Start: 1. Clone the repository:

git clone https://github.com/srinivasa-vasu/flight-delay-copilot.git

2. Start YugabyteDB:

yugabyted start

You can find detailed instructions at: https://docs.yugabyte.com/stable/reference/configuration/yugabyted/

3. Start Docker: Start the docker desktop to use the local embedding models.

4. Configure Spring Boot’s application.yml: Set up YugabyteDB URL, username/password, and Google Gemini API key. You can generate an API key from Google AI Studio.

5. Build & run:

mvn clean install
mvn spring-boot:run

The application will be available at http://localhost:8080

Full Workflow: Insights with Contextual Traceability

The prediction journey in DelayPredictCoPilot follows these steps:

1. extractRequest: Parse and validate user input (if you run in shell mode)
2. buildContext: Gather relevant context with semantic and structural queries on historical flight data
3. optimizeContext: Rank the relevance of results; performs a runtime optimization of the RAG context
4. weatherAnalysis: Augment analysis using external signals like weather data
5. predictFlightDelay: Orchestrate multi-persona evaluation including initial prediction, critique, and synthesis for final output
6. Team Simulation: Your system mimics real teams of domain experts: collaborative, critical, and adaptive

The entire workflow is orchestrated by Embabel, ensuring seamless integration and intelligent decision-making. You will get a similar plan like the one below:

hasRun_io.ai.agent.FlightPilotAgent.extractRequest: FALSE it:com.embabel.agent.domain.io.UserInput: FALSE hasRun_io.ai.agent.FlightPilotAgent.buildContext: TRUE hasRun_io.ai.agent.FlightPilotAgent.optimizeContext: TRUE hasRun_io.ai.agent.FlightPilotAgent.predictFlightDelay: TRUE hasRun_io.ai.agent.FlightPilotAgent.weatherAnalysis: TRUE it:io.ai.agent.record.FlightDocs: TRUE it:io.ai.agent.record.PredictionRequest: TRUE it:io.ai.agent.record.PredictionResponse: TRUE it:io.ai.agent.record.WeatherAnalysis: TRUE

The Nexus of Semantic and Structural Data Discovery

A crucial component of the workflow is building optimized historical context. In traditional workflow systems, context is gathered through identifier or record matching. Here, we can harnesses the full power of modern data search:

Semantic Search: Vector embeddings (using the pgvector extension) use a semantic search to identify similar historical records based on contextual similarity (for example, weather patterns, route and flight anomalies).

Structural Search: Classic SQL queries filter results by strict business dimensions based on dates, flight numbers, routes, etc.

Hybrid Approach: Both methodologies are combined, ensuring knowledge discovery reflects the real-world complexity of flight delay prediction.

This is where YugabyteDB excels, providing scalable and powerful (semantic and structural) search capabilities essential for developing modern GenAI-based applications.

The Agent Personas Approach

The Persona Paradigm: Analyst, Skeptic, Lead Analyst In the flight-predict agentic workflow, the prediction process is deliberately modeled after how expert teams collaborate in real life. This is realized through distinct AI “personas” each contributing a unique perspective and layer of scrutiny.

Analyst Persona: Acts as the primary forecaster, reviewing retrieved flight and weather contexts along with historical data to propose an initial prediction. This can be augmented with machine learning models as well. Focuses on known patterns, domain expertise, and precedent much like an aviation analyst reviewing trends and established metrics.

Skeptic Persona: Embodies critical thinking and adversarial review, challenging the analyst’s initial forecast by searching for potential blind spots, edge cases, or anomalies (“What if there’s an unexpected storm?” “Does this route usually behave differently in winter?”). Simulates counterfactual questions and stress-tests the analysis ensuring that risk factors, uncertainties, and alternate scenarios are explicitly considered.

Lead Analyst Persona: Orchestrates synthesis, much like a senior expert moderating a collaborative meeting. Integrates the initial forecast and criticisms, weighing both insight and doubt to create a balanced, nuanced prediction. Justifies the final recommendation with clear rationale making outcomes not just accurate but also explainable and defensible.

Why Use Multi-Persona Agentic Prediction?

Human-Grade Robustness and Explainability In high-stakes domains, reliable predictions necessitate not only statistical accuracy but also careful consideration of edge cases and uncertainty. The persona-based approach ensures that comprehensive knowledge is applied and that decisions can be traced back to explicit lines of reasoning, similar to how expert teams examine every angle before making a forecast.

Risk Mitigation Real-world events especially in aviation are rife with exceptions, sudden shifts, and rare risks. By embedding a Skeptic, the agentic process is forced to confront uncertainty, minimizing unanticipated failures and making agentic AI more trustworthy for enterprise deployment.

Collaborative Intelligence Inspired by how analysts, auditors, and team leads work together in mission-critical organizations, different personas mirror specialized roles, preventing monoculture thinking and promoting diversified analysis crucial for domains where no single model or expert “knows it all.”

Explainable AI: Auditability and Compliance The Lead Analyst’s rationale makes decisions defensible to regulators and business leaders. Justification and reasoning trace through the workflow where every step is clear, transparent, and documented.

Future-Proofing and Extensibility The agentic workflow can easily introduce new personas (e.g., Compliance Reviewer, Operations Expert) as requirements evolve. Each persona’s logic is modular, making upgrades or extensions natural thereby keeping the agentic workflow agile and resilient.

Conclusion

Adopting a multi-persona prediction strategy ensures that agents do more than just compute; they reason, question, and synthesise like a team of experienced professionals. This approach delivers predictions that are not only precise but also robust, explainable, and enterprise-ready establishing a validated standard for intelligent automation in complex domains.

The convergence of agentic AI using Embabel, Spring, semantic search via YugabyteDB, and the resilience of enterprise Java offers organizations transformational tools for intelligent decision automation. The future of enterprise transformation looks promising and it’s more intelligent, explainable, and robust than ever before.

👋 If you find this helpful, please click the clap 👏 button below a few times to show your support for the author 👇

🚀Join FAUN Developer Community & Get Similar Stories in your Inbox Each Week