AI Engineer · Published 2026-10-12

Just-in-Time Ontologies: What Cheap Intelligence Means for Data — Hrishi Olickel, Southbridge AI

privateReview: unreviewedConfidence: high
ontologiespipelinesagentsgovernanceschemaentity-resolutionagentic-pipelinesmodel-priorsverification-costpareto-surfingschema-mappingdata-integration
Open on YouTube ↗

Summary

Overview

  • Speaker: Hrishi Olickel
  • Channel: AI Engineer
  • Main topic: Data infrastructure transformation enabled by cheap AI intelligence
  • Purpose: To introduce the concept of just-in-time ontologies, explain why single ontologies fail, and demonstrate how agentic pipelines and Pareto-surfing can achieve high-accuracy data integration at a fraction of traditional costs. The video explores how the declining cost of AI intelligence enables a shift from rigid upfront enterprise ontologies and data warehousing to just-in-time ontologies. It argues that data infrastructure has traditionally been bottlenecked by the high cost of transformation and universal schemas, which invariably fail. By leveraging cheaper, specialized LLMs, agents, and bounded decision models, organizations can integrate data at the point of decision rather than forcing a universal superschema.

Topic Map

The Cost of Intelligence and Architectural Shifts (0:05 - 0:55)

  • Explanation: Discusses historical cost trends in computing, storage, networking, and intelligence, noting that architecture follows capability and that transformation has historically been bottlenecked by expensive intelligence.
  • Key claims:
    • Architecture follows capability.
    • All data infrastructure is built on the idea that transformation is expensive.
    • Cheap intelligence changes the economics of data transformation.
  • Examples:
    • DuckDB and vectorized query processing dropping query latency.
    • Declining storage and compute costs over decades.
  • Terminology:
    • DuckDB
    • Pareto frontier
    • Vectorized query processing
  • Why it matters: Understanding cost curves explains why legacy data architectures were built around upfront transformation and why LLMs enable a paradigm shift.

Why Single Ontologies Always Fail (1:50 - 5:16)

  • Explanation: Examines why enterprise mind maps and universal superschemas (like Cyc or large enterprise CRM migrations) fail due to lack of buy-in and the reality that data is recorded separately from decision contexts.
  • Key claims:
    • There is no superschema.
    • Ontologies are the enterprise version of mind maps.
    • You will never know all four schemas (source, storage, decision, prior) at the same time except at the moment of decision.
  • Examples:
    • Lidl SAP migration, NHS National Programme for IT, FBI Virtual Case File, US Air Force ECSS.
    • Ohio campaign finance entity resolution.
  • Terminology:
    • Superschema
    • Entity resolution
    • Source schema
    • Storage schema
    • Decision schema
  • Why it matters: Challenging the dogma of universal schemas reveals why data integration projects fail and points toward just-in-time ontology merging.

Intelligence Embedded in Pipelines and the Three Regimes (5:17 - 14:00)

  • Explanation: Categorizes data work into three regimes (write once run once, write many run once, and write many run many) and explains the division of labor between builders and pipeline workers.
  • Key claims:
    • Almost everything we do in the modern world is a transformation of data.
    • Data work breaks into three regimes: IIFEs, large migrations, and repeatable pipelines.
  • Examples:
    • Leaf-cutter ant colonies as an analogy for specialized worker castes.
    • Ohio campaign finance data integration pipeline.
  • Terminology:
    • IIFE
    • Hankweave
    • Codon
    • Repeatable pipelines
  • Why it matters: Properly structuring agentic workflows allows teams to build scalable, self-optimizing data systems.

Model Priors and Pareto Surfing (14:01 - 21:00)

  • Explanation: Explores how model priors act as a fourth schema, detailing failure modes in LLMs and how cross-model intersection and Pareto surfing optimize cost, speed, and accuracy.
  • Key claims:
    • Models bring their own priors to every task.
    • Bigger models are not always better due to memorization traps.
    • Intersecting model priors dramatically reduces errors.
  • Examples:
    • In-kind contribution spelling errors in campaign finance data.
    • Comparing Jev, Luna, and Fable models on held-out families.
  • Terminology:
    • Model prior
    • Pareto surfing
    • Checking ladder
    • FMEA report
  • Why it matters: Pareto surfing enables teams to tune workloads across cost, speed, and accuracy simultaneously.

Key Points

Transformation has always been expensive

  • Explanation: Enterprise data architecture is built on the assumption that transforming data schemas is costly, leading to rigid upfront data warehousing and master data management.
  • Evidence: Historical pricing charts for storage, compute, and IP transit vs. the emerging cost curve of intelligence.
  • Practical implication: If transformation is cheap, data pipelines can be fluid and constructed on demand.

There is no universal schema

  • Explanation: Enterprise attempts at building single universal ontologies (superschemas) fail because a customer entity definition depends entirely on the specific decision being made.
  • Evidence: High failure and abandonment rates of major government and enterprise IT migrations like NHS and US Air Force ECSS.
  • Practical implication: Stop trying to build enterprise-wide data models upfront; instead, merge source and decision schemas just-in-time.

Checking is more expensive than doing

  • Explanation: In agentic data pipelines, verifying and auditing model outputs costs significantly more in tokens and compute than generating the initial answer.
  • Evidence: Cost breakdowns of the Ohio campaign finance pipeline showing audit and settling disagreements consumed the majority of the budget.
  • Practical implication: Design pipelines with multi-tier model review where cheap models propose and capable models check.

Frameworks, Models & Processes

The Four Schemas of Data

  • How it works: Breaks down data representation into four distinct schemas that are rarely aligned simultaneously.
  • Components:
    • Source schema
    • Storage schema
    • Decision schema
    • Model's prior
  • When to use: When designing data integration, entity resolution, or ontology mapping systems.

The Six Phases of Antigile Agents

  • How it works: A structured methodology for building self-optimizing agentic data pipelines.
  • Components:
    • Spec and split
    • Decide the failure surface
    • Bounded pilots
    • Move checks into rigs
    • Reuse, loop, sequence
    • Production, maturing
  • When to use: When deploying LLM agents into complex production data workflows.

Examples & Case Studies

Resolving Ohio campaign finance donor records for 203,317 cases using AI agents.

  • Illustrates: The power of Pareto-surfing and just-in-time entity resolution at a tiny fraction of projected human consulting costs.
  • Lesson: Combining cheap reasoners with automated checking ladders achieves human-level ground truth at minimal cost.

LLM models misinterpreting 'in_kind' campaign contributions due to spelling variations and sign conventions.

  • Illustrates: How model priors and shared sign conventions cause correlated failures across different LLM families.
  • Lesson: Models bring preconceived notions; checking code and cross-model validation are required to catch systemic biases.

Actionable Takeaways

  • Immediate:
    • Stop spending months designing rigid upfront database schemas.
    • Use bounded pilots to test multiple model architectures against a small data slice.
    • Implement checking ladders in code rather than relying entirely on chat prompts.
  • Strategic:
    • Embrace just-in-time ontologies where data is transformed at the moment of decision.
    • Treat intelligence as a cheap, abundant resource rather than a scarce bottleneck.
    • Build repeatable pipelines (hanks and codons) that mature in cost and performance automatically.
  • Questions to investigate:
    • What are the four schemas operating in your current data pipeline?
    • How much of your data budget is spent on checking vs. doing?
    • Where can you replace rigid database migrations with agentic just-in-time transformation?

Claims Worth Verifying

  • All major enterprise data infrastructure is built on the assumption that transformation is expensive. (Architectural philosophy)
  • Checking model outputs costs approximately 4x as much as generating initial answers in complex pipelines. (Empirical cost metric)

Notable Quotes

"All of our data infrastructure today is built on the idea that transformation is expensive. What if that wasn't true anymore?" (at 0:32) "Ontologies are the enterprise version of mind maps. It's this tar pit that sucks us all in." (at 2:32) "There is no concept of a customer that's divorced from the question you want to answer." (at 7:23) "The moment a number exists, it argues for a result." (at 13:26) "The answer is there is no ontology. Not a universal one at least. There never was one." (at 33:48)

Compressed Summary

  • Data architecture has historically been constrained by expensive compute and transformation.
  • Universal superschemas and single enterprise ontologies invariably fail because data and decisions are decoupled.
  • Just-in-time ontologies merge source and decision schemas dynamically at query time.
  • Checking and auditing model outputs dominate pipeline costs and require rigorous programmatic guards.
  • Keywords: ontologies, pipelines, agents, governance, schema
  • Core insight: Cheap AI intelligence enables a paradigm shift from rigid upfront enterprise ontologies to fluid, just-in-time data transformations driven by agentic pipelines.

Core insights

7
Mental Modelhigh noveltymoderate evidence

Four distinct schemas must align for correct data interpretation — source schema, storage schema, decision schema, and the model's own prior — and they are only simultaneously knowable at the moment of decision, meaning ontology merging should be deferred just-in-time rather than fixed upfront.

Why it matters

Reframes schema design from a static, upfront modeling exercise into a runtime concern tied to a specific decision context, which changes where ontology logic lives in a pipeline (at inference time, not in the warehouse DDL).

Generalization

Any system that maps heterogeneous data into a decision-ready representation should treat the mapping as decision-scoped and computed at query/decision time rather than as a global invariant.

You will never know all four schemas (source, storage, decision, prior) at the same time except at the moment of decision.
Open source video
There is no superschema.
Open source video
Mechanismhigh noveltymoderate evidence

Treating the model's prior as an explicit fourth schema means model choice participates in the semantic layer, and correlated failures arise because different LLM families share sign/spelling conventions — so intersecting priors across models is an error-reduction mechanism, not just redundancy.

Why it matters

Gives a concrete reliability lever: cross-model intersection reduces correlated prior-driven errors, and warns that 'bigger model' can be worse (memorization traps) rather than uniformly better.

Generalization

Where multiple models share training-data conventions, their errors are correlated; ensembles only help to the extent priors are actually independent, so diversity must be measured, not assumed.

Models bring their own priors to every task.
Open source video
Intersecting model priors dramatically reduces errors.
Open source video
Bigger models are not always better due to memorization traps.
Open source video
How model priors and shared sign conventions cause correlated failures across different LLM families.
Open source video
Tradeoffhigh noveltymoderate evidence

In agentic data pipelines, verification/auditing dominates cost over generation — checking is more expensive than doing — so pipeline budgets should be modeled around audit and disagreement resolution and designed as multi-tier review where cheap models propose and capable models check.

Why it matters

Inverts the usual cost intuition (generation as the expensive step) and implies the checking ladder is the primary cost and reliability surface to optimize.

Generalization

As generation becomes cheap, the bottleneck shifts to validation; system architecture should be organized around verification cost and escalation policy rather than generation throughput.

Checking is more expensive than doing
Open source video
audit and settling disagreements consumed the majority of the budget
Open source video
Design pipelines with multi-tier model review where cheap models propose and capable models check.
Open source video
Architecturemedium noveltymoderate evidence

Data work partitions into three regimes — write-once-run-once (IIFEs), write-many-run-once (large migrations), and write-many-run-many (repeatable pipelines) — each implying a different build/run division of labor and different agent scaffolding.

Why it matters

Provides a routing decision for when to throw agents at a one-off transformation versus when to invest in a reusable, self-optimizing pipeline with rig-based checks.

Generalization

Workload classification by reuse frequency should drive whether effort goes into ad-hoc agent reasoning or into hardened, reusable pipeline components.

Data work breaks into three regimes: IIFEs, large migrations, and repeatable pipelines.
Open source video
Almost everything we do in the modern world is a transformation of data.
Open source video
Practicemedium noveltymoderate evidence

Pareto surfing tunes a workload across cost, speed, and accuracy simultaneously, rather than optimizing a single dimension — implying model selection is a continuous multi-objective search rather than a fixed choice.

Why it matters

Operationally enables teams to hold accuracy constant while sliding along the cost/latency frontier, which is essential for high-volume pipelines like entity resolution over hundreds of thousands of records.

Generalization

Any AI pipeline with heterogeneous per-item difficulty should allocate model capacity per item via a frontier search rather than a single global model choice.

Pareto surfing enables teams to tune workloads across cost, speed, and accuracy simultaneously.
Open source video
Combining cheap reasoners with automated checking ladders achieves human-level ground truth at minimal cost.
Open source video
Practicemedium noveltyweak evidence

A six-phase 'Antigile Agents' methodology (spec and split, decide the failure surface, bounded pilots, move checks into rigs, reuse/loop/sequence, production & maturing) prescribes externalizing checks into reusable test rigs rather than leaving them as ad-hoc per-run validation.

Why it matters

Gives a concrete lifecycle for deploying LLM agents into production data workflows where the failure surface is explicitly chosen before scaling.

Generalization

Agent reliability work should productize verification into reusable rigs early, because checks recur across items and regimes while generation logic does not.

Move checks into rigs
Open source video
Spec and split
Open source video
Decide the failure surface
Open source video
Bounded pilots
Open source video
Empirical Resultmedium noveltymoderate evidence

Large universal-schema programs (NHS National Programme for IT, FBI Virtual Case File, US Air Force ECSS, Lidl SAP migration) are cited as evidence that superschema-driven integration fails, supporting just-in-time ontology merging as the alternative.

Why it matters

Provides historical grounding for abandoning enterprise-wide upfront data models, a significant strategic and architectural reversal for data platform teams.

Generalization

Centralized schema standardization efforts fail at scale when the schema must serve decision contexts that are not known in advance.

High failure and abandonment rates of major government and enterprise IT migrations like NHS and US Air Force ECSS.
Open source video
Stop trying to build enterprise-wide data models upfront; instead, merge source and decision schemas just-in-time.
Open source video

Deep dives

4

Just-in-time ontology merging vs upfront superschemas

Research question

Can a runtime ontology merger that combines source and decision schemas at decision time achieve higher accuracy on entity-resolution tasks than a fixed upfront schema, under controlled data with multiple decision contexts?

Why

This tests the core architectural claim that deferring schema alignment to decision time is both feasible and superior to universal enterprise models, which have a history of failure.

You will never know all four schemas (source, storage, decision, prior) at the same time except at the moment of decision.
Open source video
There is no superschema.
Open source video
Source video

Verification cost dominance and scaling in agentic pipelines

Research question

What is the ratio of verification cost to generation cost in agentic data pipelines, and how does it scale with record volume and disagreement rate?

Why

If checking dominates budgets, then pipeline architecture, cost models, and optimization efforts must shift from generation to verification and disagreement resolution.

Checking is more expensive than doing
Open source video
audit and settling disagreements consumed the majority of the budget
Open source video
Source video

Model prior independence and ensembling gains

Research question

How independent are model priors across LLM families, and how much marginal error reduction does cross-model intersection provide over a single strong model?

Why

Cross-model verification is a proposed reliability lever, but its value depends on prior independence; measuring this prevents wasting budget on redundant ensembles.

Intersecting model priors dramatically reduces errors.
Open source video
How model priors and shared sign conventions cause correlated failures across different LLM families.
Open source video
Source video

Reusable verification rigs across data work regimes

Research question

Can verification checks be abstracted into reusable rigs that transfer across IIFE, migration, and repeatable pipeline regimes without re-encoding decision context?

Why

Reusability is the key to amortizing verification cost; failure to transfer means per-decision reasoning costs recur indefinitely.

Data work breaks into three regimes: IIFEs, large migrations, and repeatable pipelines.
Open source video
Almost everything we do in the modern world is a transformation of data.
Open source video
Source video

Article ideas

4

Stop Building Superschemas: The Case for Just-in-Time Ontologies

Universal enterprise data models invariably fail because they ignore the decision context in which data is used; the alternative is to merge source and decision schemas at runtime, enabled by cheap intelligence.

Angle

Argues against centralized schema standardization and presents just-in-time ontology merging as a pragmatic, decision-scoped alternative, drawing on historical failures like NHS and FBI VCF.

Source video

Checking Is More Expensive Than Doing: Rethinking AI Pipeline Budgets

As generation becomes cheap, verification becomes the dominant cost in agentic data pipelines; teams must architect around audit ladders and disagreement resolution, not just generation throughput.

Angle

Inverts conventional cost intuition and provides a budgeting framework for multi-tier model review where cheap models propose and capable models check.

Source video

Your LLM Ensemble Is Less Diverse Than You Think

Different LLM families share training-data conventions that correlate their errors, so naive ensembling yields diminishing returns; prior independence must be measured before relying on cross-model intersection.

Angle

Exposes the hidden correlation of model priors and argues for empirical independence checks as a prerequisite for ensemble design.

Source video

The Three Regimes of Data Work: A Routing Framework for Agentic Pipelines

Data work partitions into write-once-run-once, write-many-run-once, and write-many-run-many regimes, each demanding different agent scaffolding and build/run division of labor.

Angle

Provides a decision framework for when to use ad-hoc agents versus investing in reusable, self-optimizing pipeline components.

Source video

Project ideas

4

Just-in-Time Ontology Merger

new

A runtime ontology merger that combines source and decision schemas at query time achieves higher entity-resolution accuracy than a fixed upfront schema across multiple decision contexts, at lower total cost.

Proof of concept

Prototype a merger that, given a source schema and a decision context, uses LLM calls to generate a mapping on the fly; evaluate on a dataset with multiple decision contexts (e.g., Ohio campaign finance) against a hand-crafted global schema.

Measurement

Accuracy per decision context, total cost per decision, and amortized cost over N decisions compared to the fixed schema baseline.

Source video

Prior Independence Benchmark

beyond-evals

Cross-model intersection error reduction is bounded by measured pairwise prior correlation; for models sharing training conventions, ensemble gain over a single strong model is less than 10%.

Proof of concept

Build a benchmark of entity-resolution tasks, measure per-model accuracy and pairwise error correlation across 3-5 LLM families, and simulate intersection policies.

Measurement

Pairwise error correlation matrix, marginal error reduction from intersection vs. single best model, and identification of correlated failure modes.

Source video

Verification Cost Profiler

new

In agentic data pipelines, verification cost exceeds generation cost by a factor that grows superlinearly with record volume and disagreement rate.

Proof of concept

Instrument a reference entity-resolution pipeline to decompose token/compute cost per stage (propose, check, resolve), varying record count and disagreement rate.

Measurement

Cost ratio (check/generate) as a function of volume and disagreement rate; scaling exponent; identification of dominant cost drivers.

Source video

Reusable Verification Rigs

gatehouse

Verification checks encoded as reusable rigs transfer across data work regimes (IIFE, migration, repeatable pipeline) with less than 20% re-encoding effort, reducing total verification cost over repeated runs.

Proof of concept

Build a rig abstraction for a set of checks (e.g., entity format, consistency, disagreement triggers) and apply it to one-off, migration, and recurring pipeline tasks.

Measurement

Transfer success rate, setup time reduction, verification cost per run across regimes.

Source video

Architectural implications

4

Schema/ontology alignment is deferred to decision time rather than fixed in the warehouse layer.

Before

Upfront master data management and universal enterprise ontologies encode entity semantics once, globally.

After

Ontology merging happens just-in-time per decision, combining source and decision schemas at runtime.

Consequence

Ontology logic becomes a runtime component (agent/pipeline code) that must be versioned, tested, and audited like application code, not a DDL artifact.

Source video

Verification cost dominates generation cost in agentic data pipelines.

Before

Pipelines budget primarily for the transformation/generation step and treat validation as lightweight.

After

Architecture centers on checking ladders, audit trails, and disagreement-resolution paths with tiered model capability.

Consequence

Cost modeling, latency SLOs, and observability must instrument the checking path as the primary expense and failure surface.

Source video

Model choice becomes part of the semantic layer via the model prior as a fourth schema.

Before

Model selection is a deployment/infra decision orthogonal to data modeling.

After

Model identity and prior characteristics influence entity interpretation and must be selected per workload via Pareto surfing.

Consequence

Model routing/selection becomes a data-quality concern, requiring per-model error profiling and cross-model intersection policies.

Source video

Data work is segmented into three regimes by reuse frequency.

Before

One pipeline pattern is applied uniformly across ad-hoc and repeated data tasks.

After

Ad-hoc IIFEs use lightweight agent reasoning; repeatable pipelines invest in reusable rigs and self-optimization.

Consequence

Platform teams need two distinct toolchains and staffing models ('builders' vs 'pipeline workers') rather than one.

Source video

Tradeoffs and failure modes

4

Cross-model verification vs correlated priors

Benefit

Intersecting model priors dramatically reduces errors by catching prior-driven mistakes.

Cost or risk

Different LLM families can share sign and spelling conventions, producing correlated failures that defeat naive ensembling.

How model priors and shared sign conventions cause correlated failures across different LLM families.
Open source video
Source video

Bigger models vs memorization traps

Benefit

Larger models offer more capability and may resolve harder items.

Cost or risk

Bigger models are not always better because of memorization traps, so scaling capacity can degrade specific tasks.

Bigger models are not always better due to memorization traps.
Open source video
Source video

Cheap generation vs expensive verification

Benefit

Cheap intelligence makes on-demand transformation and just-in-time ontology merging economically viable.

Cost or risk

Auditing and settling disagreements consumes the majority of the pipeline budget, so savings on generation may be eaten by verification.

audit and settling disagreements consumed the majority of the budget
Open source video
Source video

Just-in-time ontologies vs upfront enterprise models

Benefit

Avoids the failure mode of universal superschemas by merging source and decision schemas only when needed.

Cost or risk

Repeated on-demand merging must be made reusable; otherwise per-decision reasoning costs recur and cannot be amortized.

Stop trying to build enterprise-wide data models upfront; instead, merge source and decision schemas just-in-time.
Open source video
Source video

Open questions

5

How independent are model priors in practice, and how much error reduction does cross-model intersection actually yield beyond a single strong model?

Why unresolved

The summary reports correlated failures and that intersection reduces errors but gives no measured error-reduction figures or independence metric.

Research direction

Build a benchmark that measures per-model and pairwise error correlation on held-out entity-resolution families and quantifies marginal gain from intersection.

Source video

What is the token/compute cost ratio between generation and the checking ladder, and how does it scale with record volume?

Why unresolved

The summary states audit consumed the majority of budget in one pipeline but provides no ratio, scaling curve, or comparison to alternatives.

Research direction

Instrument a reproducible pipeline to decompose cost per stage and derive scaling laws for checking cost vs. records and disagreement rate.

Source video

How can checks be 'moved into rigs' in a way that generalizes across regimes without re-encoding decision context each time?

Why unresolved

The Antigile methodology names the phase ('Move checks into rigs') but the summary does not describe rig structure or reuse mechanism.

Research direction

Prototype a reusable verification rig abstraction and test transfer of checks between IIFE, migration, and repeatable pipeline regimes.

Source video

When does Pareto surfing's per-item model allocation beat a single globally chosen model after accounting for routing and orchestration overhead?

Why unresolved

The summary asserts simultaneous tuning across cost, speed, and accuracy but provides no crossover point or overhead accounting.

Research direction

Run a controlled experiment comparing global model choice vs per-item frontier routing on accuracy-per-dollar and latency.

Source video

What is the actual measured accuracy and cost against human ground truth for the Ohio campaign finance entity resolution at 203,317 cases?

Why unresolved

The pipeline is described as achieving human-level ground truth at minimal cost, but no numeric accuracy or cost figures appear in the summary.

Research direction

Publish or replicate an audited accuracy/cost evaluation of the entity-resolution pipeline against a human-labeled golden set.

Source video

Key claims

8
causalVerification needed

Universal enterprise schemas (superschemas) invariably fail because a customer/entity definition depends on the specific decision being made.

Evidence

There is no superschema.

Question

What is the measured failure/abandonment rate of major superschema-driven integrations, and do failures trace to decision-context mismatch?

Source video
causalVerification needed

All four schemas (source, storage, decision, model prior) are only simultaneously knowable at the moment of decision.

Evidence

You will never know all four schemas (source, storage, decision, prior) at the same time except at the moment of decision.

Question

Can a just-in-time merge at decision time recover mappings that an upfront schema could not, under controlled data?

Source video
comparativeVerification needed

In agentic pipelines, checking is more expensive than doing, with audit and disagreement settling consuming the majority of budget.

Evidence

Checking is more expensive than doing

Question

Across what pipeline shapes and volumes does verification cost exceed generation cost, and by what factor?

Source video
causalVerification needed

Intersecting model priors dramatically reduces errors, but shared sign and spelling conventions across LLM families cause correlated failures.

Evidence

Intersecting model priors dramatically reduces errors.

Question

How much do error correlations between model families reduce the expected gain from intersection/ensembling?

Source video
causalVerification needed

Bigger models are not always better due to memorization traps.

Evidence

Bigger models are not always better due to memorization traps.

Question

On which task families does model scale degrade due to memorization of training-set conventions?

Source video
opinionVerification needed

Combining cheap reasoners with automated checking ladders achieves human-level ground truth at minimal cost, as demonstrated on 203,317 Ohio campaign finance don/donor records.

Evidence

Combining cheap reasoners with automated checking ladders achieves human-level ground truth at minimal cost.

Question

What accuracy and total cost were measured relative to human ground truth on the held-out case set?

Source video
predictionVerification needed

Cheap intelligence changes the economics of data transformation, allowing fluid, on-demand pipelines instead of rigid upfront data warehousing.

Evidence

Cheap intelligence changes the economics of data transformation.

Question

At what intelligence cost point does just-in-time integration become cheaper than maintaining a fixed schema?

Source video
opinionVerification not requested

Data work partitions into three regimes (IIFEs, large migrations, repeatable pipelines), implying differentiated build/run tooling.

Evidence

Data work breaks into three regimes: IIFEs, large migrations, and repeatable pipelines.

Source video

Connections

5