How Analytics Works

June 3, 2025 · Baoss

Business Analytics 2025: Generative AI and Autonomous Agents for Real-Time Decisions

First, in June 2015 we published on this very blog an article titled «How Analytics Works». We talked about customers «more and more connected» and about «mobile devices». We also insisted on capturing profiles and histories to deliver relevant information «at the precise moment». Back then, the star solution was the IBM Rational suite: DOORS, Team Concert and Build Forge. Specifically, the milestones were to cut release cycles from four to two months and reduce email traffic by 50%. Today, BAOSS IT consulting defines analytics differently: it means systems that decide and execute, not just inform.

BAOSS IT consulting: how analytics works with generative AI and autonomous agents

Today, nine years later, that article seems written in another geological era. Today, mobile is no longer a channel: it is the customer’s nervous system. Data is not «captured»: according to IDC, 2.5 quintillion bytes are generated daily. Moreover, analytics does not inform: it decides, executes and learns in milliseconds. Now, autonomous agents do it — agents that reason, plan and act without human intervention.

In fact, throughout 2024 and 2025 BAOSS has been deploying this new layer of intelligence in banking, retail, logistics and industry. What follows is not theory: it is real patterns, production metrics and lessons learned (sometimes the hard way). All of it comes from projects where traditional analytics has given way to cognitive systems composed of LLMs, RAG, knowledge graphs and multi-agent flows.

The real problem in 2025-2026: abundant data, slow decisions, missing context

The organizations we talk to every week share three identical pains, regardless of sector or size. Specifically:

  • Decision-data latency: 73% of executives surveyed by Gartner in 2024 admit that «by the time the dashboard reflects the problem, the window for action has already closed». In other words, data arrives late.
  • Semantic fragmentation: then, data lives in an average of 17 sources per company (data lake, ERP, CRM, IoT, PDFs, Slack, Jira tickets), each with its own dictionary. Thus, a «customer» in Salesforce is not the same as a «user» in the data warehouse or a «subscriber» in the emailing platform.
  • Execution gap: finally, data teams deliver insights (charts, alerts, predictions). However, the last mile —launching a campaign, rerouting a shipment, blocking a fraudulent transaction— remains manual, fragile and slow.

That is why descriptive (what happened) and diagnostic (why it happened) analytics no longer differentiate a company. The value lies in autonomous prescriptive analytics: systems that detect an anomaly, simulate scenarios, choose the best action and execute it via API, MCP (Model Context Protocol) or an RPA agent. This closes the loop in < 200 ms.

BAOSS IT consulting’s reference architecture: the «operating brain»

First, there is no one-size-fits-all. Even so, after a dozen production deployments we converge on a five-layer pattern we call the Cognitive Analytics Stack. First, if you are wondering which partner you need for this leap, our guide on how to choose an AI technology partner in 2026 sets the criteria. Then, for autonomous systems, this review of the risk of AI agents is required reading.

  1. Unified ingestion & semantics: first, Kafka / Redpanda + Debezium CDC + dbt semantic layer + knowledge graphs (Neo4j / Kuzu) mapping canonical business entities. As a result, «customer» means the same thing in real time across the whole ecosystem.
  2. Temporal & vector feature store: then, Feast + pgvector / Qdrant / Milvus. Here we store both tabular features (RFM, LTV, risk) and embeddings of unstructured interactions (calls, chats, tickets, manuals).
  3. Multi-agent reasoning engine: after that, orchestrated with LangGraph or CrewAI. The specialized agents —Detector, Simulator, Validator, Executor— share context via MCP and long-term memory in Redis + PostgreSQL.
  4. Private & governed LLM layer: first, vLLM + Ollama on own GPUs (H100 / A100) or sovereign cloud. Base models are Llama 3.1 70B Instruct, Nemotron 3 Ultra and Qwen 2.5 72B. For complex reasoning tasks: GPT-4o / Claude 4 Sonnet via API with EU data residency. In addition, there is zero prompt injection thanks to NeMo guardrails + continuous evaluation with RAGAS and DeepEval.
  5. Actuation & closed observability: then, REST/gRPC APIs + Webhooks + Temporal.io for long-running flows. Metrics are business metrics (not just technical) in Grafana + semantic business observability with OpenTelemetry.

The key: first, everything is code, everything is versionable, everything is auditable. Thus, there is GitOps (ArgoCD / Flux) from the prompt to deployment on Kubernetes (EKS / GKE / on-prem Rancher).

Case 1 — Retail banking: real-time fraud detection and blocking (anonymized)

Context: first, a Spanish financial institution with more than 3M customers and 120M transactions/month. The legacy rules engine (Drools) has accumulated 4,200 rules, 68% false positives and an average latency of 1.8 s. Meanwhile, a team of 12 analysts reviews alerts manually.

Then, the deployed solution (Q1 2025, 14 weeks):

  • First, CDC ingestion of core banking + cards + online banking → Kafka → unified feature store (tabular + embeddings of merchant description, device, geolocation).
  • Then, a Detector agent (Llama 3.1 70B fine-tuned on 18M labeled historical transactions) + a Simulator agent (Monte Carlo, 10k scenarios/tx) + a Validator agent (explains in natural language why it blocks or allows).
  • The actuation policy: allow / challenge (3DS2) / block / queue for human. Execution goes via MCP over the issuer’s authorizer API.
  • Finally, observability: dashboards for precision@k, p99 latency, false positives/negatives per segment and automatic weekly drift detection.

As a result, production metrics (week 18 post-go-live):

  • P99 latency: from 1.8 s to 87 ms (a 20x factor).
  • False positives: from 68% to 19% (a 72% reduction).
  • Real fraud detected: +34% (net recovery of €2.1M/quarter).
  • Analyst workload: –81% (from 12 to 2.5 FTEs dedicated to complex cases).
  • ROI: 4.3x at 6 months (CAPEX + OPEX vs. fraud savings + efficiency).

Key lesson: Fine-tuning the LLM on proprietary data and continuous evaluation with RAGAS (faithfulness > 0.92, answer_relevancy > 0.89) were decisive. In fact, the base model (GPT-4o) hallucinated non-existent merchant codes; our own model did not.

Case 2 — Omnichannel retail: autonomous replenishment and dynamic pricing across 1,200 SKUs (anonymized)

Context: first, supermarket chains + e-commerce, 85 stores and 1.2M tickets/week. Weekly planning was done in Excel + SAP APO, with 8.4% stockouts, 12% overstock and an average margin of 22%.

Then, the solution (Q3 2024 – Q1 2025, 22 weeks):

  • Knowledge graph: product ↔ store ↔ customer ↔ supplier ↔ logistics ↔ seasonality ↔ local events (weather, holidays, concerts). In other words, all the business context in a single model.
  • CrewAI agents: Forecaster (Temporal Fusion Transformer + LLM for causal reasoning), Optimizer (mixed-integer linear programming with constraint programming), Pricer (contextual bandit + elasticity estimated by LLM) and Executor (MCP → SAP EWM + e-com pricing engine).
  • The human-in-the-loop remains only for exceptions: margin < 12%, critical stockout or competitor promo.

As a result (week 26):

  • Stockouts: from 8.4% to 2.1% (-75%).
  • Overstock: from 12% to 4.3% (-64%).
  • Average margin: from 22% to 26.8% (+4.8 pp).
  • Planning cycle time: from 4 h/week (manual) to 12 min (autonomous + validation).
  • Incremental EBITDA: +€3.7M/year (5.1x ROI at 12 months).

Technical detail: The Pricer agent uses Claude 4 Sonnet to reason about cross-elasticity. To do so it reads category reports, supplier news and customer reviews (RAG over 40k docs). Also, the 200k-token context window allows including the complete 2-year history per SKU-store.

Case 3 — Last-mile logistics: dynamic routing with negotiating agents (anonymized)

Context: first, a logistics operator with 4,500 routes/day, 120 hubs and a mixed own + subcontracted fleet. The classic optimizer (OR-Tools) ran every 30 min and could not absorb hot incidents (traffic, breakdowns, demand spikes). Also, cost/km was €1.38; the < 24 h delivery SLA stood at 89%.

Then, the solution (Q4 2024, 10 weeks):

  • First, event streaming: truck telemetry (1 Hz) + WMS + OMS + TomTom traffic + weather API → Kafka → vector feature store (route + driver + vehicle embeddings).
  • Then, a LangGraph multi-agent system: Monitor (detects deviation > 15 min), Negotiator (LLM agents that negotiate reassignment between hubs/fleets via MCP), Replanner (solves the dynamic VRP with column generation + LLM heuristic), Dispatcher (push to driver app + subcontractor API).
  • The policy: if the incremental cost is < 8% vs. the original plan → auto-execute. If it exceeds 8% → escalate to a human with 3 reasoned alternatives.

As a result, the KPIs after 14 weeks:

  • Cost/km: from €1.38 to €1.21 (-12.3%).
  • SLA < 24 h: from 89% to 96.4%.
  • Human interventions/day: 340 →

    And what about the real productivity of these systems? In fact, our article on AI productivity and the 9% gap sums up the case data.

    Prefer to talk to us directly? Contact the BAOSS team and tell us about your challenge.