iAxCientífico: Why a Compound AI System Beats Purely Agentic AutoML

How a Dominican materials factory runs self-improving demand forecasting on a single server — and what Berkeley and Databricks research tells us about why this architecture works.

The demand for forecasting in small and mid-sized manufacturing is enormous. A construction-materials factory in the Dominican Republic needs to know exactly how much cement, steel, and lumber to order each week. Missing the mark by five percent means either lost sales from stockouts or dead inventory that ties up cash flow.

The conventional answer is "AutoML" — throw a black box at your data and hope it produces an accurate model. But black boxes are opaque, hard to audit, and notoriously difficult to improve when they start degrading. And the alternative pitched today is "agentic AI" — point a Large Language Model at your pipeline and let it decide the next step.

We built the third option: iAxCientifico, a Compound AI System where an LLM proposes features, real solvers train models, PostgreSQL stores institutional memory, and n8n coordinates the orchestration. Every component does what it's actually good at. None of them is the system. The system is the cooperation.

The Research: Why Compound Beats Monolithic (and Agentic)

The argument for compound systems over monolithic LLMs or pure agentic loops is no longer theoretical. It's the consensus among the people actually building production AI.

Berkeley AI Research (BAIR)

In their landmark February 2024 paper "The Shift from Models to Compound AI Systems", Matei Zaharia, Omar Khattab, and colleagues at UC Berkeley's AI Research lab analyzed what's actually delivering state-of-the-art results across AI. Their finding was definitive:

The evidence was clear. AlphaCode 2 achieved 85th-percentile human performance on coding contests not through a single larger model, but through a carefully engineered system: generate 1M candidate solutions, filter them, score them, cluster them. AlphaGeometry combined an LLM with a symbolic math engine to reach between silver and gold at the International Math Olympiad. Microsoft's MedPrompt exceeded GPT-4's medical-exam accuracy by 9% through a chain-of-thought + nearest-neighbor-search + 11-sample ensemble system.

The researchers identified four reasons compound systems outperform monolithic approaches:

• Some tasks are easier to improve via system design. Scaling a model gives lower returns than engineering a compound system. A single model might solve coding challenges 30% of the time; tripling its budget to 35% is still useless. But a compound system that samples multiple solutions, tests each, and filters can reach 80% with today's models.
• Systems can be dynamic. Models are trained on static datasets. Compound systems combine models with retrieval and tools to incorporate timely data.
• Improving control and trust is easier with systems. Neural networks alone are hard to control. A system can filter outputs, provide citations, and verify facts through deterministic checks.
• Performance goals vary widely. A single model has a fixed cost-quality curve. A compound system can route different inputs to different components, mixing cheap and expensive models for a given budget.

Databricks Mosaic AI

Databricks reached the same conclusion from a different direction — the production deployments of their customers. In their June 2024 announcement of Mosaic AI Agent Bricks, they documented a concrete case study:

Their research showed that 60% of LLM applications already use RAG and 30% use multi-step chains. The industry was already practicing compound systems before the research named it.

Additional supporting findings

• DSPy (Stanford / Databricks) — Omar Khattab's open-source framework operationalizes compound AI by composing LLM calls into modules with declarative signatures, then optimizing them as a system end-to-end.
• FrugalGPT (Berkeley) — learned routing between model cascades outperformed the best single LLM by 4% at the same cost, or reduced cost by 90% while matching quality.
• BCG Benchmarks — compound loops achieve 25–35% faster workflows than sequential alternatives while maintaining or improving accuracy.
• Microsoft Power-of-Prompting — chaining strategies with nearest-neighbor search, model-generated CoT examples, and 11-sample ensembling outperformed specialized medical models like Med-PaLM.

The iAxCientífico Architecture

iAxCientifico is the AutoML component of the APEXiA product family, running for Harder SRL, a construction-materials factory in the Dominican Republic. It builds and continuously maintains demand-forecasting and churn-prediction models — without a human data scientist sitting at the keyboard.

The architecture is a textbook example of the compound AI pattern. Here's the full system diagram:

Four Cooperation Subsystems

The system has four cooperating components. None is the system. The system is what you get when they cooperate.

The Theory Log: Institutional Memory in PostgreSQL

The most important table in the system isn't any operational view or materialized dashboard. It's cientifico.demand_feature_registry — a theory log where every feature the system has ever tried lives permanently, with its reasoning.

CREATE TABLE cientifico.demand_feature_registry (
  id               SERIAL PRIMARY KEY,
  feature_name     TEXT UNIQUE NOT NULL,
  feature_type     TEXT NOT NULL,        -- 'calendar' or 'query'
  build_code       TEXT NOT NULL,        -- materialization SQL/Python
  forecast_code    TEXT NOT NULL,        -- inference-time expression
  prophet_compatible BOOLEAN DEFAULT TRUE,
  xgboost_compatible BOOLEAN DEFAULT TRUE,
  fill_value       NUMERIC DEFAULT 0,
  enabled          BOOLEAN DEFAULT TRUE,
  proposed_by      TEXT DEFAULT 'manual',
  reasoning        TEXT,                   -- the theory
  visited_when     TEXT[],               -- "what data is needed to revisit"
  run_id           UUID,                 -- run-id discipline
  created_at       TIMESTAMPTZ DEFAULT NOW()
);

As of today, 62 rows exist. 17 are enabled (active in production). 45 are disabled. The acceptance rate is around 27% — which is high relative to traditional AutoML because the LLM proposals are hypothesis-driven, not brute-force kitchen-sink. Every accepted feature has a theory attached. Every rejected feature has a reason.

A concrete case: the quincenal payday cycle

In the Dominican Republic, most workers are paid twice a month (the 15th and end of month). This is the quincenal cycle, and it's a real driver of construction-materials demand — small contractors stock up around paydays.

Claude Opus proposed it 9 times in different shapes. All were rejected. Qwen proposed a similar feature once — a clean binary flag — and it landed. Why? Qwen had a different prior about what makes a good feature for gradient-boosted trees. Trees don't need sinusoidal encodings or distance metrics. They need binary splits.

This is proposer diversity in action. Running multiple LLMs as proposers produces a wider search space than any single model. This is the same logic that makes ensemble methods work, applied at the meta level of feature engineering.

Why Not Just Use an Agent?

This is the question that matters most in 2026. An agentic loop would point an LLM at the data, give it tools, and let it decide the next step end-to-end. On the surface this seems like the natural next step after compound systems. But for production forecasting, it has three structural problems.

Problem 1: Agentic loops trade speed for autonomy

• Each decision in model-building (which feature, what aggregation, which hyperparameters, when to stop) is a language-model call.
• A single cycle takes hours instead of seconds.
• The factory needs a model produced overnight, not at the end of next week.
• The compound version makes ~5 LLM calls per cycle and does the rest in deterministic code in seconds.

Problem 2: Hallucination compounds across steps

• An agent's output at step N becomes input at step N+1. Errors don't get corrected by reality between steps.
• The model can "reason" about results it never measured, hyperparameter sweeps that don't actually run.
• Every component boundary in a compound system gets a hard reality check: the trainer either succeeded or didn't, WMAPE either improved or didn't.

Problem 3: There's no math floor in pure agentic systems

• When an agent says "this feature reduces error by 4%," that claim is either an LLM judgment (often wrong) or a real measurement (then the LLM didn't make the claim — the math did).
• The honest version of an agentic ML system would call deterministic tools at every step where math is involved — which is exactly the compound architecture, just with a different label.

How Linux Powers Everything

iAxCientifico runs on a single host — 128GB RAM, two AMD Radeon AI PRO R9700 GPUs, no Kubernetes, no managed orchestration. Here's how Linux components combine:

The Compound Advantage: What Berkeley and Databricks Predict, Production Delivers

The Berkeley AI Research paper identified four reasons compound systems outperform monolithic approaches. Here's how iAxCientifico maps to them:

The Databricks FactSet case study is the real-world proof: 55% → 85% accuracy by modularizing the task into specialized compound steps rather than trusting a single model.

Why This Won't Be Superseded by Better Agents

There will come a day when agentic systems are fast enough, cheap enough, and accurate enough to handle end-to-end AutoML on a single model call. When that happens, the agentic version of this system might be possible.

But the compound version will still produce the same forecast for a fraction of the cost. The compute spent on language-model reasoning at every step of an agentic loop is exactly the cost that compound architectures avoid by routing math to math and language to language.

In other words: the agentic transition will turn compound architectures from "the only way that works" into "the cost-optimized way that works." For operators who care about margin per tenant — like a materials factory where forecast accuracy directly maps to inventory and cash flow — that's the version that matters anyway.

Architecture also benefits from two different model-progress trajectories simultaneously. Local open-source models (Qwen, Gemma) will keep improving — meaning the local proposer slot will silently get stronger, for free, on hardware already owned. Meanwhile, premium-tier frontier models will do genuinely agentic work that nothing today can match. The compound architecture hosts both; the operator doesn't have to predict which tier will dominate.

Looking Forward

The system has known unfinished edges — all tractable additions to the same loop:

1. Substrate expansion. BCRD (Banco Central de la República Dominicana) macroeconomic indicators — construction PMI, GDP, inflation, remittances — are wired into the system. When new data lands, the revisit queue automatically fires re-proposals of previously-rejected features that needed that data.
2. Multi-objective optimization. Currently optimizing for aggregate WMAPE. Adding peak-period accuracy (the moments operators care about most) and confidence-interval calibration.
3. Drift detection on accepted features. Quarterly re-testing of every active feature under current conditions, with quiet retirement of features that have stopped pulling weight.
4. FE↔HP coupling. When FE tentatively accepts a feature, firing a focused HP re-tune for the new feature space before committing. This is the single biggest architectural unlock remaining.

None require redeliberating the system. They're additions to the loop, in the same loop's spirit.