All of it is autonomous, so one might say, why do we still need BI tools, or therefore a semantic layer, or even a context layer? It's hard to predict the future, but as someone working with newer models as well as older ones, I could see that Fable for example is one-shotting work in minutes that previously took me many iterations with Opus 4.8 (below you see my recent Claude and Codex use (roborev only)). With the right workflows to brainstorm first a spec, then an implementation plan, it's really amazing how fast and precisely one can build with the right amount of inputs we give, and taste.

So what then is left for us humans to do in the data work context? Many are defaulting to adding or curating context, ergo the rise of a context layer. I see even more talks about added Ontologies. Maybe you ask yourself, what is that even? Do we need all of it?

This article is a primer about the context layer, the difference between a classical semantic layer contained in every BI tool, and an external semantic layer.

What is Context, and Its Context Layer?

But we can't talk about the new shiny context layer tools, ontologies or any other, before we define context, and how much context we need. If we go by the definition of the word context, Cambridge Dictionary says:

The situation within which something exists or happens, and that can help explain it

Jessica Talisman, who writes about semantics, the vocabulary and the intersections of ontologies, defines context in information science as:

Describes the relational structure that holds meaning in place.

This sounds very much like metadata, the data about the data we collect in logs, orchestration runs, table information, index information. But let's go one step further, what's a Context Layer?

What's a Context Layer?

There are multiple definitions out there, and bear in mind, this term is less than a year old, but Andreessen Horowitz describes a "Modern Context Layer" to contain[^1] three pieces:

1. Accessing the right data. [...] we'd want to ensure the agent has access to all the data it needs [...] captured in internal systems, GDrive/Slack, etc.

2. Automated context construction [...] emphasis of focus should be on high signal context – for example, looking through past query history can be high signal in determining the most referenced tables and most common joins, and data modeling solutions like dbt or LookML can provide clear definitions for business metrics.

3. Human refinement – Automated context construction may be able to form a large portion of the context corpus, but it can't create the full picture. [...]

I defined it in Beyond the Semantic Layer in a similar fashion:

The context layer primarily supports the accuracy of SQL queries, continuous updates to the business context, and governance. Additionally, with a newer context layer, we can include more relevant business insights that are stored internally, usually in unstructured form, in tools like Notion as business documentation.

So it seems clear, we focus on less "classical" data sources from databases, or structured tables, but more free-flow text that humans wrote in docs, Confluence, Notion.

Comparison to a Semantic Layer, and how They Work together

Now that we defined context and its layer, it begs the question, what's the difference to a semantic layer (which, to some, might be another rather vague definition)? I know, I have written about past BI integrated ones, and more modern ones like Cube, Malloy, dbt one, but it still seems everyone has a different definition.

The definition of a semantic layer, as we discussed in Why Semantic Layers Matter (including an example of how to build one), is defined by Julian Hyde, creator of Morel Language, and an early employee of Looker and LookML:

A semantic layer, also known as a metrics layer, lies between business users and the database, and lets those users compose queries in the concepts that they understand. It also governs access to the data, manages data transformations, and can tune the database by defining materializations. Like many new ideas, the semantic layer is a distillation and evolution of many old ideas, such as query languages, multidimensional OLAP, and query federation.

So that means, a semantic layer understands the semantics, the metrics and governance access and data transformation, and has a link to (multi-dimensional) OLAP and query languages, while the context layer is more focused on gathering context and refinement between humans and agents.

I see the two, a semantic layer and a context layer, working for distinct fields, and working hand in hand:

• Semantic Layer: Definition is written as logic that compiles to SQL, like a metric or a dimension
• Context layer: Holds everything else: the rules that can't be explained, and everything that is unrelated to a dedicated query.

The Context Layer and Agents Paradox

In a semantic layer, Notion Docs, Confluence pages, and other unstructured text didn't count as real data sources. There's no incremental load on Markdown, so we didn't include them.

There is also another angle in play. Before agents, it was hard to keep track of free flow Markdown text, finding out what has changed in the incremental load, and what's useful, what has the biggest signal as a16z said above. But with the help of agents, we can now integrate more. Agents can do the bulk of the work, and that's why context layers popped up in the first place.

It's a paradox: if we didn't have agents, we wouldn't need this much context. But we need more context because of agents, and we can only manage it because we have agents.

We can load more data than ever now because agents do the integration work that wasn't feasible before, but we also need to load more data than ever because agents need to be smarter to use it well. The agent needs every bit of human-written information to increase its context and make better decisions, but that's only possible because of agents in the first place.

Jacob saw a similar paradox in Are Semantic Layers Really Necessary? and says:

there's a little bit of a paradox: you need some level of conformity to communicate well, but also if you have too much conformity, you have a commodity. You need space to have some differentiation.

How much Context Do We Need? And what Kind?

That begs the question: How much context do we need, and what kind? Should we gather all Markdown files we find, or use the JIRA tickets where we defined our tasks?

And what's the quality of these JIRA tickets? They might be super up-to-date, but missing a whole lot of information, so what kind of "context" do we get from them, or do we want?

With agents, we could probably say the more context, the better, and hopefully the agent identifies the high-signal and valuable data out of empty Jira tickets . But assuming we gathered all of the above context, how do we actually manage it? How do we update it, how do we make sure it's correct?

This is actually where we always land at the same fundamental questions of Data Engineering Lifecycle and data governance, especially in an enterprise setting with multiple actors and people. Because it's easy to build up context initially, once. But the hard part is updating it, maintaining it, having rules, having a governance strategy.

So the Context Layer integration, as well as the semantic layer, becomes a data governance and enterprise process definition problem.

Open Standards for Metrics and Data Quality

What helps us here are open standards. Luckily we just recently got the Open Semantic Interchange (OSI) standard, recently renamed to Apache Ossie. They standardise the syntax around semantic layer declarative configuration. The goal is to have an open-source, vendor-agnostic specification for describing and exchanging semantic models.

Not that we end up with many different proprietary YAML definitions for LookML, Cube, dbt Semantic Layer, Snowflake's internal one, etc. as we have it today. If you write in the standard, it can be easily mapped to any semantic layer definition.

Metrics to Measure the Data Quality of Context

Another part of the puzzle and how good context layers will be, is the data quality. The outcome, the context itself, strongly depends on the quality and how up-to-date and correct the data is.

One thing I was pondering for a long time: how do we measure that? In my previous job we had a single test score to represent data quality, something like an Net Performance Score (NPS) we used to represented the mobile network and network quality as a single metric that characterizes the overall performance. So as a network provider, I won't need to check every number on each phone call. I can aggregate it up to an NPS score as part of a region, commune, or country. This is a common approach in network profiling, but in data we don't have that luxury yet. Maybe we should?

Why am I saying all of this? Because to be able to massively ingest context, and documentation autonomously, without checking it, we need a measure. And that needs an open standard on data quality. Measures such as last updated date, creator (agent/human), ratings, etc. would be needed to condense a full score. If we have this, we can add a load more context, faster.

But right now, we do not have it, unless we use a data catalog, where catalogs scan metadata and humans rate data sets etc. But with faster agents and everything autonomous, this model needs some improvements.

And what the Heck is an Ontology?

Another term I see more frequently used and talked about, is an Ontology. I include it here, because if we talk about context, and the newly created context layer, I believe it's a good vehicle to explain the world for agents that need to understand not only the data our business holds, but also need to link it to common sense and how the world functions in real life. And that is what ontologies are really good at.

Ontology: Broader Context to Explain World Models

These are not something new. I used them back in 2017, when Airbus (where I was working at the time) announced Skywise, an open data platform for airplane parts. And do you know what it was built on? On Palantir Foundry, a data lake with a deep foundation in Ontologies.

If we go to Wikipedia, it defines an Ontology as follows:

In information science, an ontology encompasses a representation, formal naming, and definitions of the categories, properties, and relations between the concepts, data, or entities that pertain to one, many, or all domains of discourse.

In simpler words, usually existing objects in the world can be described through an ontology. For example, an ontology is seen as the whole below:

Source: Core concepts for Palantir - Docs

Palantir defines it inside their tool called Foundry as:

Ontology is a categorization of the world, it's the digital twin of an organization, integrating the organization's data and models into a coherent whole by mapping them to object types, properties, link types, and action types.

The Airport, Flight, Delay, Airline, Aircraft each result in an object type, which is the schema definition of a real-world entity or event, not an ontology in itself.

Arrows (Departed From, Operated By, Hub For, etc.) are link types and the schema definition of a relationship between two object types, similar to how we model connections in the relational model in an Entity Relationship Diagram (ERD).

Things like Duration, Founding Date, Range are properties, which are the schema definition of a characteristic of a real-world entity or event. So the ontology is the whole schema (all five tables/datasets plus how they join together).

But in terms of computer/information science, the term was first used in information systems in 1967 by Mealy, though the more significant early work came from McCarthy and Hayes in 1969, who argued that intelligent machines need metaphysically adequate representations of the world. Hayes' 1978 paper "Naive Physics I: Ontology for Liquids" appears to be the first computer science paper with "ontology" in the title. Find more in What is an Ontology? (2018)

Compare Semantic with Context Layer, and Knowledge Graph and Ontologies

Others such as Ananth Packkildurai share it combined into a simple diagram where taxonomy and knowledge graph get added to showcase the technical semantic architecture leading to the context graph:

Source: What an Ontology for AI Agents Actually Needs

So another term, "Knowledge Graph", simply explained, means information stored in a graph database and visualized as a graph structure, prompting the term knowledge "graph". But it helps us see the semantics as the start (the definitions -> can be independent of database or tooling if you have an external layer), and then external elements of the world outside of my company's business are described as an ontology, what Ananth calls the "schema layer," since it defines the classes, properties, and rules everything else has to conform to, which, combined with a graph (the "instance layer," holding the actual data), leads to the "context graph".

Mehdi calls the difference between a semantic and context (page 5): "'Semantic' is just a fancy word meaning there's a specific meaning for certain concepts and metrics in a company. Some are easy and stable; others live in people's heads and shift over time." And says that the good news is that LLMs are very good at pulling data from many sources, so we can use the full semantic context and not just a separate layer.

What's the Take Away? Graphs and AI Agent Integration?

I know that was a lot, with a lot of definitions and potentially new terms brought together.

What got clearer to me, is that data gets more interconnected. When you follow the data news, as I do, many call for the context layer and connect it with a graph, because the graph is the best representation of complex interconnected knowledge, internal, external or models for describing the world, as the airport/flight example above shows.

Hamilton, Till, Jacob and Garret though make a counter argument in Context belongs in the warehouse, saying not to overcomplicate with sophisticated retrievals (embeddings, graphs). They showcase MotherDuck's new Guides work by having the agent browse a topic tree of curated guide titles and pick the right one without any keyword or vector search. This suggests that sometimes a simple index is enough.

Sophistication Is a Cost, Not a Default

Put those two paragraphs side by side and you get a contradiction: interconnected knowledge argues for a graph, and MotherDuck's own Guides argue that a flat index of titles beats embeddings and graph traversal. Both are right, they're just answering different questions.

Sophistication is a cost you should only pay if the outcome is worth much more than that cost. The airport/flight ontology earns a graph because the domain genuinely is cross-domain and interconnected: an aircraft links to a flight, a flight to an airline, an airline to a hub, and the value is in traversing those relationships. MotherDuck's guide index doesn't need that, because the actual bottleneck isn't relating entities to each other, it's picking the one right document out of a hundred, and an agent does that more reliably by scanning titles than by ranking similarity scores. A graph would have added retrieval overhead and, per MotherDuck's own evals, picked worse.

The same lens explains why a semantic layer earns a deterministic, machine-callable interface (SQL, REST, GraphQL) that a context layer doesn't get. It comes down to who's actually asking, and what it costs to be wrong. A semantic layer's numbers get called directly by a dashboard or a scheduled job, with no human and no LLM in the loop, so it has to be right every time, and that guarantee is worth the cost of building and maintaining it. A context layer feeds an agent that's still reasoning, still capable of misreading a guide or picking the wrong table, so there's still a checkpoint between the context and the number that ships. A context layer doesn't carry that weight, at least not yet: it depends entirely on your setup and your data governance. As more agent-mediated work goes straight to a dashboard with nobody reviewing it, the case for giving context layers their own consistency guarantees only gets stronger.

So before reaching for a graph, an ontology, or a deterministic interface, ask what the retrieval or consistency problem actually is, who consumes the result, and what a wrong answer costs. Match the tool to that answer, not to what's trendy this quarter.

The Way Forward: Tools and AI Agent Integration

You might also ask, if agents like Fable are one-shotting work that used to take many iterations, what's actually left for humans to do?

There's already a handful of context layer tool that build a Context Layer. I have written about ktx, and am checking out OmniGraph, but there are many more with Nao or more data catalog flavored Marmot, OpenMetadata or DataHub just to name a few, and all working closely with AI agents to ease governance and management.

Another integration is through the ORM (Object-Relational Mapping). I once read: "an ORM to a database is what a semantic layer is to a domain knowledge", so maybe we just need ORMs for agents?

So what's the way forward then?

AI Agents Read the Business Knowledge

When we give an AI agent the business knowledge it needs through a context layer, or semantics with SQL queries and joins, it can query a warehouse correctly.

An agent can read a table's schema, but the schema won't reveal the inside knowledge of how "revenue" is defined, which tables join to which, or which columns are unreliable. A semantic layer and a context layer are two different answers to that gap and are not mutually exclusive.

We can see a real-world illustration of how the two layers of semantic and context can cooperate in Anthropic's self-service data analytics with Claude. They write about how their agents are using skill instructions to leverage the semantic layer first for self-service data analytics. The skill file itself states plainly that the semantic layer is the mandatory default path for every data question, with raw SQL as the fallback used only once the semantic-layer path is shown not to cover the ask. MotherDuck Guides play a related role as curated knowledge for the agent, though MotherDuck ships the context layer first and treats a dedicated semantic layer as a separate, later question, so the routing is not the same.

In the end?

So, back to where I started: if a model like Fable can one-shot in minutes what used to take me many rounds with Opus, what's actually left for us in the data work context? Looking back at the initial semantic layer, the evolution to a context layer, and combining it with an ontology, these are not really competing tools or methodologies. They are all interconnected and work in a net. The definitions for the metrics in SQL/YAML in a semantic layer, ingestion pipeline of unstructured text and keeping it up-to-date with context layers, and making sense of the world for the agents with ontologies.

And most of what we have evolved to, is mostly due to the sheer power and advancement of agentic work, that agents can autonomously keep up with metadata and data we want to convert into context. But at the same time, it always defaults back to the fundamental question of what my data governance looks like, and what my overall data architecture is to achieve the goal at hand.

And as a16z's three-part context layer implied, as well as Anthropic's semantic-layer-first skill: someone still has to decide what's true. We still need the human in the loop, especially with data. And that's the whole crux of Amdahls Law, as long as a person or a team needs to decide or gets involved, we lose the overall speed, but I think that's the price we still pay, if we want good, verified data quality in our enterprise data warehouse or analytics platforms.

And as I raised with the metric to measure data quality, which we do not have, it confirms another true statement, that the hard part in data is never building semantics or the context once, it's how and who keeps it correct and maintained. That's the answer to my opening question: not a tool, but judgment, the same judgment behind the "human refinement" step a16z pointed to, and the same one behind deciding whether a problem is worth a graph or is better served by a flat index.

Large language models are getting exceptionally good at writing the SQL with the right context, and at maintaining just that. But most often, deciding what "revenue" means still requires deep company-specific knowledge (for now).

Listen more on these very related discussed topics with the already teased Jacob's podcast about Are Semantic Layers Really Necessary?. Or check out the great example of how AI agents can help with creating a semantic layer using the open source semantic layer Malloy at AI Writes the Semantic Layer | MotherDuck.

[^1]: They call it a "modern" context layer. I'm not sure we already went through the evolution of context layers, so calling it modern does not add much value. To me it's the first version of a context layer.

We wanted to find out by analyzing a slice of query history across human and agent users. Here’s what we uncovered. Our systems can’t afford to stay the same.

On methodology, a quick note: here we’re comparing queries written during a two week period in the MotherDuck UI (“human”) versus those written through the MCP server (“agent”). This is the most consistent way to segment with a high degree of confidence between human and robot authorship.

Agents Query 29 Times More Often

The most visible difference between agentic query patterns and humans is just the sheer volume of queries. Agents ran 29 times more queries than humans in the last month. By itself that is quite astonishing. If you look at the chart though, the trend shows no signs of slowing down. Each month in the last three, the gap has roughly doubled: 6x, 16x, 29x. If that pattern holds, in 2 more months agents will be issuing a full 2 orders of magnitude more queries than are run in the UI manually (the “old fashioned way” - it feels crazy to say that!).

Another interesting observation is that as recently as January of this year, humans did more of the querying. Then agentic queries overtook manual queries in February and haven’t looked back.

Efficient agent ergonomics are no longer optional. The accuracy of robot-authored queries matters tremendously. The importance of investing in the context layer is increasing dramatically month on month. Context can both boost accuracy and reduce how many tokens it takes to reach the right answer.

Agents are now the dominant consumers of the data platform.

Organizations Have More Robots Than Humans

Self service analytics has long been a holy grail in data. Some have quested after it for many years (I count myself among them, having helped build a self-service platform!). Others consider it a myth, too high a risk, or at best an inefficient approach.

Our data shows twice as many agents as human users on average per organization. At the extremes there is an even larger difference. The organization with the most agent users has 7 times as many agents as the org with the most human users has humans! More and more people are learning about their data by using agents to interpret it.

As a self-service-maximalist, this is music to my ears! However, I am not naive. I have seen plenty of data misinterpretation and have certainly been guilty of it myself more than a few times.

New types of folks across your company are asking data questions, or rather, new agents from across your company are asking questions on their behalf. The context layer helps here too, but as adoption increases across new teams, it needs to be as automatic as possible. People are connecting up agents on their own and just firing away questions independent of any central training program.

Like it or not, agents have accelerated data democratization.

Humans Pause to Think, Agents Query Rapid-Fire

The gap between queries is far shorter for agents than humans. The median delay between queries for agents is 4 seconds, but 60 seconds for humans. This makes agentic workloads far burstier than their human equivalents. I see this myself as well: I am far better at building one query at a time, but with a few subagents, agents can be highly parallel.

This has significant system implications. Your data platform has to be ready to handle higher concurrency than before, but is also more likely to have periods of quiet after each burst. Can your system scale down in between those bursts of queries, or do you have a cluster that is running even when the agent is “Razzmatazzing”? If you are scaling up to handle that concurrency, those idle times get expensive quickly.

However, the opposite extreme has high costs as well. Those queries run in short succession often examine the same data. A completely fresh compute environment for each query sacrifices all the benefits of pre-warmed data. Keeping your data warm can boost performance and lower costs.

Agents fire off queries in rapid bursts that can be taxing to rigidly configured data infrastructure.

Experimentation is the Way of the Robot

We’ve seen this behavior in coding. Agents like to do small experiments to confirm their assumptions. Our dataset shows this behavior extends to data analysis. The median query by an agent only scans 7000 rows of data vs. 200,000 by humans. Agents issue large requests too, but they issue so many small ones that it lowers the median. Similarly, many agent queries are acquiring context and metadata by reading table schemas.

Is your data system prepared for many small, highly concurrent queries? Or is there a latency floor where even the smallest queries take multiple seconds? Agents love to experiment, and the faster they can do that, the quicker your company’s data questions get answered.

Using a full compute cluster just to list the data types in a table is overkill. Does your data platform have the ability to cache data locally? Then when an agent asks 3 specific questions about the same dataset, it will only be pulled once. If the entire catalog could be synced locally (it can!) then exploratory queries become instant and free.

The small experimental queries that agents depend on need to be both fast and cost efficient.

Our Systems Need to Change

Taken together, these agentic workload patterns should change how we design and implement our data platforms.

Organizing the context of your data is an investment with far greater returns than ever before. Not only does context dramatically increase agent query accuracy, it also reduces costs (55% savings in those same benchmarks) by requiring fewer tokens to complete the same analysis.

Having a well constructed context layer also makes it far easier for all teams (executive, operational, and everything in between) to begin uncovering data insights on their own. This can lead to tremendous value and far better decisions across the company. Agents open the door, but inside will they find a dusty antique shop or an orderly library?

Small, highly concurrent query patterns are the norm with agents. Those patterns are also burstier than human ones and require faster scaling up and scaling down. Having a data platform that can handle that very different load shape in a performant and cost effective manner will become more and more critical.

Finally, how can we take better advantage of compute and caching where agents are running? Any round trips that are saved on background schema research or follow up questions on similar datasets directly translate into performance and cost wins.

We’ve been architecting MotherDuck specifically for the agentic reality we all live in. Give us a test - there’s nothing quite like benchmarking with your own data and workload.

How does this change the way we work? What does this say about the future of using AI in data? Oh, and let’s get it set up on your machine while we’re at it. It won’t take long!

The Pareto Frontier Has Shifted

We used a custom harness and OpenRouter to run the DABstep benchmark across a variety of models and compare them to Qwen3.8 27B running locally on my laptop(s). I’ll dig into the details in a moment, but first, how did it do?

To say I was impressed with Qwen 3.8 is an understatement. Look how far to the top-left it is!

For free, or under $0.50 if you count electricity costs, Qwen outperformed OpenAI’s GPT 5.6 Luna Max that cost over $8. That’s over 17 times cheaper. Just a few weeks ago, we were singing Luna’s praises and its revolutionary impact. It’s still really powerful. Things just move fast here in AI land.

The Qwen 4 bit run was done on an M5 Macbook Air (32GB RAM), and the 3 bit run on my older M1 Pro Macbook Pro (16GB RAM). Since the Air only uses 30 Watts to the Pro’s 100W, it is even more cost efficient!

Gemini-3-Flash remains the most accurate model, but for an additional 2.3x in price over Luna. These benchmarks are slightly noisy, so it is possible that some small prompt improvements could bring performance closer together.

Things are not looking great for Sonnet 5 here. More expensive and significantly less accurate is not a great combination.

As another open weight model data point, Kimi K3 is quite accurate, but at a high price. It is suboptimal vs. Gemini-3-Flash aside from its openness.

You can explore the results in this MotherDuck Dive:

How Qwen3.8 Changes the Way We Work

This truly is intelligence too cheap to meter. We are quite literally only metering electricity, and on a 30W Macbook Air, that’s 1 single light bulb! Left a light on last night? Could have answered a whole bunch of data questions!

While this benchmarked questions and answers about data, there are a number of other similar workloads where these models are useful. Background research has a lot of similarities. The first task in both is to use business context to understand the question, then the tool usage for research is just web search instead of kicking off a local DuckDB query. SQL is a good proxy for other lightweight coding tasks like scripting or automation too. These tasks are now free, so feel free to kick them off in the background even if there is only a chance they are useful.

With a local model this good, and a laptop that powerful sitting on your desk, every day you wait to set this up is a day you’re burning money on tokens! If you have a fairly powerful laptop, you could get several dollars per day (upwards of $100 per month!) of value out of it for pennies in electricity.

Aside from the raw dollars, completely removing the risk of racking up a big bill overnight by accident is really freeing. The failure mode of running slowly on a big task instead of churning through credits is a big benefit. (Side note, MotherDuck’s billing model works the same way - you can’t accidentally send a query across thousands of machines!).

One of my favorite data workloads that fits that pattern is query optimization. “Hey Qwen! Look at all the queries I ran today and make them faster. You have the next 12 hours to experiment. Use data science best practices. Go!”.

Powerful open models open up other doors around self hosting these open weight models, possibly fine tuning them, or even tapping into a decentralized network of independently owned Macs for cheap inference!

Let’s Get Your Laptop Fans Whirring

So how can you get this set up locally to get in on these benefits? First, what kind of machine do we need?

You’ll want a laptop with over 16GB of unified memory or a discrete graphics card with 16GB of RAM. For things to work most smoothly, having 32GB of RAM does help a fair bit. Macs (especially Macbook Pros) also have higher GPU memory bandwidth so they tend to be higher performing than other laptops.

As a total newcomer to local models, it only took me an hour or so of trial and error to get the basics working. Now you can skip those steps and be up and running in minutes!

1. Install DuckDB
2. Install LM Studio
3. Download a quantized (smaller) Qwen3.8 27B model
   1. For a Macbook with 32GB RAM I recommend a 4bit quant like Qwen3.8-27B-MLX-4bit
   2. For a Macbook with 16GB RAM you’ll want a 3bit quant. I like IQ3_XXS from the unsloth family of models.
4. [Optional] Download an MTP (Multi-Token Predictor) for a speed up in some cases
5. Ask your agent to start the LM Studio OpenAI-compatible endpoint server with the model you downloaded. These settings worked well for this benchmark:
   1. 16384 tokens of context
   2. The MTP if you downloaded it
   3. Reasoning set to low or off
6. Connect your favorite agent harness (OpenCode, etc.) to that server
   1. Or use a custom harness like in our benchmark repo
7. Point DuckDB at your data and ask a data question!

I did a number of smaller tests to tweak settings to try and get the most out of my machine. I found the best approach was to ask my agent to build a DOE (design of experiments) to try a variety of combinations of settings. This is important! The settings are very interrelated, so tuning one at a time will not give you the results you’re looking for. I also monitored memory pressure and swapping (meaning I asked Claude to measure that for me!) and asked for ways to lower memory use as well.

Memory is the most precious resource when running a local model, so I would recommend a clean restart before any benchmarking. At least close all your Chrome tabs…

I ended up getting about 5-7 tokens / second when looking at total elapsed time on my M5 Macbook Air, which is close to the 8.8 tokens/sec that memory bandwidth would project.

When using an older M1 Pro Macbook Pro with 16GB RAM, I used a 3bit quant. That means that the model’s weights were rounded even more aggressively in order to save RAM. Accuracy suffered somewhat (only 96.4% accurate instead of 98.6% with the 4bit), but it still worked, even on nearly 5 year old hardware! I saw about 5 tokens/second looking at elapsed time, because the memory bandwidth on the M1 Pro chip is actually higher than the M5 [non-pro] on the Macbook Air, but the M5 has some nice neural accelerators that give it an edge.

What is This MTP Thing?

MTP, or multi-token prediction, is a really cool approach to boosting output by guessing what the next few tokens will be in advance, then checking if they were correct. It’s most similar to speculative execution in CPUs. A CPU will do branch prediction to try and execute calculations ahead of time (exploring the most common side of an if statement, for example). When it gets things right, you get faster speeds. If it’s wrong, it just falls back to running your calculations in series.

Since the tokens are checked, there is no risk of any inaccuracy. I like risk free performance!

On the more modern Macbook, MTP was helpful with a draft size of 3. I saw somewhere around a 30% boost.

On the older Macbook Pro, MTP was actually slowing me down! It’s because the bottleneck was somewhere else in the system - the hardware just wasn’t designed with this kind of workload in mind. It took too much time to guess ahead and check those answers.

How Did We Benchmark?

For all the details, check out our GitHub repo

Our custom harness uses the DABStep benchmark to simulate how a data team should manage their context layer. First, general documentation (including some SQL snippets) is fed into Claude Fable 5 and converted into MotherDuck Guides. Guides are just markdown living right next to your data that are linked together with relationships. If you want to work locally, markdown files and some links might just do the trick.

So yes, we do use a large frontier model for part of this workload, but it is a fast and inexpensive portion of the flow. The cost sensitive part is when the question and answer sets are evaluated and that’s where the local models come in.

Once an initial context layer is built, it is iteratively tested with the smaller AI model against 26 Q&A pairs as a training set. Each question must match an exact text output. If any questions are answered incorrectly by the smaller model, the context layer is improved to document missing assumptions and business rules. The improvement uses the larger model to try and really refine that central set of definitions.

With a 26/26 score exiting the training and improvement loop, the full test set of over 400 questions is run and scored. This set is run using the smaller model as well because that is the only scalable way to run this kind of process in production.

Nobody should run Fable for their evals at scale unless their company rhymes with “gyroscopic”. I guess they could use Sol if it rhymes with “orange banzai”.

The Rest of the Story

I’m convinced that local models have finally reached the tipping point of being useful. Qwen3.8 27B in particular shocked me and made me rethink what is possible in a 27 billion parameter model.

There are still some things that are not quite equal though. First, the runtime:

Qwen took 5-6 minutes to answer each question on average vs. about 25 seconds for Gemini-3-Flash or 40 seconds for GPT 5.6 Luna. There are some disclaimers here though! I think I could tune things up a little bit more, so there could be another 20-30% performance left on the table. New quantizations keep coming out that push Qwen even further as well.

A key factor though is the hardware. M5 Max Macbook Pros actually have 4x the memory bandwidth of the Macbook Air. If that translates to 4x the performance (a decent assumption), then 90 seconds starts to be a lot closer to the frontier lab models.

However, I was only really able to run 1 prompt at a time locally. I routinely blasted 15 questions at a time through OpenRouter for this benchmark, and you can scale out prompts on the cloud as much as you are willing to pay for. Subagents are quite handy to run in parallel.

This approach also only applies to those with beefy enough hardware. Some brief Claude research estimates around 1/3rd of laptops have over 16GB RAM, which means most folks still aren’t going to be able to take full advantage. If you limit it to just Macs with 16GB+, for their faster memory bandwidth, that number drops to more like 1/30th of folks.

But I’d guess it’s a bit more than 3% of the folks reading this post, so if you have the horsepower, you should try this out!

In this benchmark, the construction of the context layer was also still done with a large frontier model (here, Fable 5). Local models are unlikely to cover all use cases just yet, at least on midrange consumer hardware.

Lastly, we are only considering electricity costs since we assume you already have a laptop. If you include depreciation expense for the laptop itself, the cost of a local model increases to about $6 per 1000 questions answered. What’s the math there? If we assume a laptop costs $2000 and lasts 4 years, then 6 minutes of depreciation per question gives you $5.70 in costs to answer all 1000.

So, don’t buy a Macbook Air just to run Qwen. You should also, you know, use the laptop.

Get That Laptop Quacking!

Local models are strong enough that they are worth the hour they take to get set up. Pair them with DuckDB, and you have a powerhouse data exploration and analysis toolkit for free, right where you’re already working.

If your data is too big to analyze locally, MotherDuck’s hypertenancy architecture gives each agent their own sandbox in the cloud. That comes with nice compute isolation guarantees (no agent can slow down the CEO’s dashboard!) as well as data compartmentalization (your agent’s data is private by default). Plus, costs are per sandbox, so no one query can explode across servers and balloon your spend. MotherDuck’s Guides also give you a super easy way to make sure that your business context is right at your agents’ “fingertips” whenever they need it.

Qwen3.8 27B and DuckDB is a uniquely powerful combo to use the laptop you already have to understand your company’s data, and MotherDuck is there if you need more power.

Happy analyzing!

Since launching our MCP server in November 2025, we've been investing in making MotherDuck work well with AI. But agents don't all live in chat windows anymore. A big chunk of them run in coding tools, CI jobs, and sandboxes where the natural interface is a shell. And a shell is where the rest of your infrastructure already lives: your CI, your deploy scripts, your Makefiles.

So we built a CLI. Use it to give your agent a MotherDuck environment it can operate directly, or use it on your own to deploy and manage MotherDuck resources as code. Same commands either way.

With the MotherDuck CLI, creating an org, a pipeline, and a dashboard is a handful of commands, whether a human or an agent is typing them:

curl -s https://install.motherduck.com | sh    # install the CLI
motherduck login                               # existing user? browser login
motherduck new                                 # or: free org, no signup needed
motherduck query "FROM 's3://bucket/data.parquet' LIMIT 10"
motherduck flight push my_pipeline --run       # publish + run a Python pipeline
motherduck dive push my_dashboard              # publish a hosted dashboard

In this post, I'll walk through why we built it, run a real end-to-end session with Claude Code driving the CLI (with actual timings from my terminal), and explain when to reach for the CLI vs our existing MCP server.

Why a CLI?

MCP has been great for getting started. You go to the Claude or ChatGPT connector directory, authenticate to MotherDuck in a few clicks, and your agent gets a bunch of tools. That flow works well when the agent lives in a chat client.

A CLI puts the work where the agent already lives. MCP tools are remote calls: every result comes back through the model. A CLI runs in the agent's local environment, next to grep, git, and the filesystem. motherduck flight push hn_flight does the same thing whether a human types it, a CI job runs it, or Claude Code calls it, and the agent only spends tokens on the decision, not on the execution.

It also keeps the work outside the context window. Every MCP tool result lands in the context, and you pay tokens for it. With a CLI, the agent can pipe motherduck query into a file, grep the three rows it cares about, or diff two dive sources on disk, and only the relevant part ever reaches the model. DuckDB runs locally too, so file-shaped work (authoring code, staging data) happens on the machine and ships to the cloud in one call. Fewer round trips through the model means fewer tokens burned.

And since it's a plain command, it's scriptable. The same CLI you hand to an agent is the one you put in a Makefile or a GitHub Action to deploy flights and dives as code. No AI required.

Second reason: setup with no browser. An agent running in a CI job or a sandbox can't click through an OAuth screen. (You can run the MCP server with a token too, but the CLI makes it the default path.) With the CLI, one curl command and the agent has everything it needs. If you already have an account, motherduck login gets you in. If there's a MOTHERDUCK_TOKEN in the environment (the CI case), the CLI picks it up automatically. If neither, motherduck new creates a temporary org for free, no signup, and stores the token. You also get a claim URL to attach that org to a human account later, so the agent can do the work first and you take ownership after.

Third: one surface. MotherDuck started as a DuckDB extension, which meant installing DuckDB first. The CLI ships with DuckDB inside, so motherduck query works locally and against the cloud from one install. Admin operations live in a REST API. The CLI puts queries, pipelines, dashboards, and account management behind a single interface to manage all your MotherDuck resources and assets, for humans and agents alike.

Show me the prompt

Can you use the motherduck cli to analyze this dataset : https://us.data.motherduck.com/hacker_news/parquet/hacker_news_2021_2022.parquet

This is a minimalist prompt on purpose. I gave it to Claude Code and let it figure out the rest. The dataset is 3.87M Hacker News items (stories, comments, polls). Here's what the agent did, with the wall-clock timings from my session.

Setup

The agent searches for the install command and finds:

curl -s https://install.motherduck.com | sh

This installs the MotherDuck CLI. In my case a token was already present, so the CLI connected straight to my org.

Explore before building

Before writing any pipeline code, the agent inspected the data with motherduck query, reading the parquet straight from our public datasets host (zero credential setup):

• count + time range: 4.3s
• DESCRIBE for the schema: 1.8s
• row breakdown by type: 2.3s

Here's the schema inspection, exactly as it ran:

motherduck query "DESCRIBE SELECT * FROM 'https://us.data.motherduck.com/hacker_news/parquet/hacker_news_2021_2022.parquet'"

column_name  column_type  null  key  default  extra
-----------  -----------  ----  ---  -------  -----
title        VARCHAR      YES
url          VARCHAR      YES
text         VARCHAR      YES
dead         BOOLEAN      YES
by           VARCHAR      YES
score        BIGINT       YES
time         BIGINT       YES
timestamp    TIMESTAMP    YES
type         VARCHAR      YES
id           BIGINT       YES
parent       BIGINT       YES
descendants  BIGINT       YES
ranking      BIGINT       YES
deleted      BOOLEAN      YES

And the row breakdown that told the agent what it was dealing with:

motherduck query "SELECT type, count(*) AS n FROM 'https://us.data.motherduck.com/.../hacker_news_2021_2022.parquet' GROUP BY type ORDER BY n DESC"

type     n
-------  -------
comment  3530415
story    334153
pollopt  1123
job      915
poll     134

That exploration pass paid off: the pipeline SQL that came out of it quoted the reserved "by" column, filtered on the dead and deleted flags, and picked the timestamp column over the raw epoch one. The agent found the sharp edges before they became bugs.

Read the manual

This is my favorite part. The CLI ships its own agent-facing docs:

motherduck flight guide
motherduck dive guide

Each prints a full authoring guide: supported APIs, runtime limits, gotchas like pinning the duckdb version or converting BigInt values before charting. If your org has authored its own flight or dive guidance, the CLI appends it here too. They run locally, so the agent gets everything it needs without a single web search. In my session, both the pipeline and the dashboard worked on the first try, and I credit the guides for that.

Build the flight

A Flight is a Python data pipeline that runs on MotherDuck, on demand or on a cron schedule. The agent scaffolded one locally, wrote the ingestion logic, and shipped it:

motherduck flight init hn_flight --name hn_ingest   # 0.04s
motherduck flight push hn_flight                    # 8.9s
motherduck flight run hn_flight                     # 3.0s to submit

The run itself ingested all 3.87M rows into three aggregate tables (daily activity, top domains, top stories) in 11.5 seconds of server-side compute. The agent then checked the exit code with flight list-runs and verified the output tables with one more query (2.0s) before moving on.

Build the dive

A Dive is an interactive dashboard authored as a single React file and hosted on MotherDuck. The agent wrote one index.tsx querying the tables the flight produced: KPI tiles, a daily time series with a metric toggle, a top domains chart, and a top stories table.

motherduck dive init hn_dive --title "Hacker News 2022 Pulse"   # 0.04s
motherduck dive push hn_dive                                    # 2.2s

Push returns a live URL. Since the dive reads the flight's output tables, re-running the flight refreshes the dashboard for free.

The dive created:

(placeholder: dive demo video goes here in the final post)

End to end: one prompt, about 45 seconds of CLI time, from no account to a scheduled-ready pipeline plus a hosted dashboard.

Built for agent loops

A few design choices make the CLI pleasant for agents specifically:

• Local commands (init, guide, --help) run instantly with no network call.
• Every command takes -o json for programmatic parsing:

motherduck flight list-runs hn_flight -o json

• Runs are inspectable. flight list-runs returns exit codes and flight logs returns what the run printed. When a pipeline fails, the agent reads the logs, fixes the source, and pushes again. Versions are tracked on every push, so nothing is lost.
• flight push --run collapses publish and execute into one call, which saves a round trip in tight loops.

When to use MCP or CLI

Both let an agent work with MotherDuck. The deciding question is whether the agent has a shell and a filesystem. If there's a local environment with compute available, the CLI is your best friend: it keeps big results out of the context window and lets the agent filter locally. If there's no shell (Claude or ChatGPT on the web), MCP is the way in:

• The CLI fits agents that run commands and write files: a coding agent building a dive or a flight in a repository, a CI job, or a shell script.
• The MCP server fits agents in a chat client with no shell, such as Claude or ChatGPT on the web. Use it to explore data, answer a question, and render a dive inline in the conversation.

Give your agent analytics powers

With the CLI, agents get a smooth way to set up and use MotherDuck: one curl to install, one command for a free org, built-in guides so they don't guess, and JSON output so they don't parse tables. The CLI is the same tool either way: paste the prompt above into your favorite agent (and try it with your own dataset), or wire the commands into your CI. Both get a predictable MotherDuck experience. Watch the ducking magic happen.

This cartoon has since made the rounds, but I first encountered it when MotherDuck was just a vague idea of starting a company. It illustrates that ducks really are pretty special. Four years later, it is no surprise that Amazon is figuring this out.

The first time I met Hannes and Mark, the DuckDB creators, in April of 2022, they shared that they had already been fending off acquisition offers. One of the reasons they had said no was because they were motivated by more than money; they wanted to build the world’s best database, and being subservient to someone else’s vision would get in the way of that.

Four years later, they’ve built something extraordinary. They’ve demonstrated that a single-node database can outperform the giant distributed databases of the previous decade. They’ve built a large and vibrant community of users that love the product. They’ve preserved their fierce independence and built things their own way, flying in the face of convention and trends.

Success, for DuckDB, was always going to mean that the big companies were going to get involved. It is an inevitable side-effect of success. That’s Amazon’s playbook, after all: wait until an open source project gets big enough, then launch it as a service. This typically serves to propel the project even faster, as it brings distribution, awareness, and standardization.

I believe that this acquisition is being done in a way that is best for the long term prospects of DuckDB as well as the DuckDB community. A rising tide lifts all Ducks, after all. Duck Labs is being kept as a wholly-owned subsidiary, with its organization intact. The Duck Labs team will still be working in open source. The DuckDB Foundation has iron clad control over the DuckDB IP, and DuckDB license is going to stay permissively open.

It is possible that in another couple of years this post will look hopelessly naive, as in “I’m sure that inviting the wolves over for a dinner party will turn out fine.” But even if it is easy to view Amazon as the big, bad wolf dressed up as a bookstore, incentives drive behavior. Amazon is incentivized to have a healthy DuckDB community. While they have DuckLabs as a subsidiary, there is no incentive for them to change the license or close it off; after all, if DuckDB becomes the standard, it is going to drive a lot more compute on their infrastructure, which is where they make their money.

What does this mean for MotherDuck?

MotherDuck was started in partnership with DuckDB Labs. For the last four years we’ve worked closely with Hannes and Mark, and we’ve helped push DuckDB’s growth along to become an amazing database to run as a service. When we started, DuckDB was primarily something that ran on laptops so that people could make sense of their CSV files; you don’t need concurrency or transactions to make that work well.

In the last four years, we at MotherDuck have gotten a lot of experience running DuckDB as a service. Our users run millions of “ducklings” (our term for our serverless DuckDB instances) every week. In order to make this run reliably across the broad cross section of workloads and query patterns our users have, we pushed DuckDB to be more reliable and predictable. We’ve submitted hundreds of patches to DuckDB to fix issues we’ve encountered. We’ve also built and operationalized a service that runs very well; in an age where you can vibe-code more and more things, you still can’t generate reliable infrastructure from a prompt.

MotherDuck now offers enterprise support, allowing us to share our hard-won expertise at running production DuckDB at scale. We had avoided this in the past because we didn’t want to compete with Duck Labs, who relied on this as their business model. Now that they are joining Amazon, we have the explicit blessing from Hannes and Mark that this won’t be stepping on their toes. We also think that in the aftermath of the acquisition more people are going to be building with DuckDB, and we’re here to help. Reach out here if you’re interested.

Some day, Amazon will likely release their own service based on DuckDB. After all, they’re not acquiring Duck Labs just because they love open source. We agree that DuckDB is a great engine for building a cloud data warehouse, and appreciate that Amazon sees that too. We welcome the competition.

Earlier in my career I worked on Google BigQuery during the Cloud Data Warehouse wars between Snowflake, BigQuery, and Amazon Redshift. The presence of Redshift on AWS didn’t slow down Snowflake’s growth, even on AWS. Competition between those three products was ultimately good for users; it pushed each one of them to get better. We have high confidence that whatever Amazon will build will be different enough for both their product and our MotherDuck to be successful. And what we learn from each other will lead to better experiences for our customers.

I caught up with Peter Boncz, who leads the databases group at CWI in Amsterdam and is a member of the DuckDB Foundation board, to talk about the acquisition. He is also a research collaborator with MotherDuck. He reiterated the job of the Foundation, as owner of the DuckDB IP, to preserve the open-source nature of DuckDB. He also expressed that he was happy to see AWS’s commitment to advancing open source DuckDB. Further, he shared that “this work will continue and I know MotherDuck will continue to contribute to open-source DuckDB.”

MotherDuck will continue working closely with Duck Labs engineers and continue to help improve DuckDB. Three of our engineers are among the top 10 external contributors to DuckDB. In the future, we’ll be doing even more work on making DuckDB better, both to help MotherDuck and the community. In order to expand these abilities, we’re growing our database team. If you want to work on DuckDB, please reach out, we’re hiring!

Duck Labs is growing up and leaving the nest. This is a natural and needed step. MotherDuck, true to our name, is both proud of the moment and a little bit nervous about what they’ll get up to next. We have no doubt that DuckDB will fly far, and we are excited to continue to be a big part of DuckDB's future, as DuckDB will remain a big part of ours.

If you want to give cloud-hosted DuckDB a try, you can sign up for free here.

I’ve known Tower co-Founder Serhii Sokolenko since we worked together at Google. He was one of the most impressive PMs I had ever met. Serhii went on to Snowflake, where he met his Tower co-founder, Brad Heller. When I heard Serhii was starting Tower, initially I was disappointed because that meant I wouldn’t be able to hire him to work at MotherDuck. But I kept tabs on what Tower was up to. Brad was equally impressive as a technology leader and put together a strong technical team who proved they could move fast and ship.

The choice to use Tower’s technology for MotherDuck actually goes back before Flights; we were originally looking to whitelist a tool to help our customers ingest data more easily into MotherDuck. After all, if you can’t get your data in, it doesn’t matter how great the data warehouse is.

When AI suddenly became relevant for data teams, we realized we were thinking about the data-ingestion problem incorrectly. We didn’t need canned connectors; Claude can write the code to move data from one place to another. We shipped the ability to host, orchestrate, and schedule your LLM-written data pipelines as our Flights feature.

The parts that Claude didn’t provide-- the sandboxing, scheduling, and observability-- were exactly the functionality that Tower provided. By building on top of Tower, we were able to launch Flights in only a matter of weeks without compromising on features like observability and reliability.

Tower’s runtime will also allow us to evolve our Flights to provide flexible and robust data agents to our customers. Running a data ingestion pipeline isn’t fundamentally different from running a data cleaning or data investigation agent, so it feels like a natural next step to use Tower as an agent orchestrator. The infrastructure the Team has built will make it faster and simpler to launch these new capabilities.

The Tower feature that I’m especially excited about is the ability for a Tower job to expose a stable URL, making it callable from anywhere. What this means is that a MotherDuck Flight can become a custom data API. Moreover, if you combine this with MotherDuck Dives, our hosted data visualization technology, you can build a full-blown application with a single prompt.

To make it concrete, imagine that you’re building an app that lets you visualize user restaurant recommendations on a map; you can build a great Dive for that. But then let’s say you want your users to be able to add their own recommendations; you’d create a Flight that allows creation and modification of their own recommendations. By putting Flights and Dives together, you can build rich, secure, scalable applications.

Earlier this year, I predicted a future in which data engineering becomes an agent supervision problem. Tower will let us surf the wave of data agents by providing the platform on top of which the agents run. Then our customers can go further, faster, funner, and with more ducks.

If you’d like to give MotherDuck a try, you can sign up yourself on the site, or direct your favorite agent to https://new.motherduck.com/.

We set out to prove that AI could build and operate a semantic layer. It could. But for us, the most important insight had nothing to do with the semantic layer.

Framing the experiment

Many companies have found using a semantic layer to be helpful for managing metrics, but does that still hold in the AI era where agents write great SQL?

We posed two hypotheses when we set out to test the semantic layer, using Malloy as our runtime of choice.

1. An accurate semantic layer in Malloy can be built “hands-off” in a loop using AI agents and existing context to create a set of context + Malloy to be consumed by other agents.
2. Using Malloy for semantic definitions will be more token efficient and faster than using Markdown + SQL, while holding the accuracy bar at 100%.

The results? We could indeed construct an accurate semantic layer in Malloy in a “hands-off”, agentic manner. However, it was much more expensive to operate than simply using Markdown + SQL. In rough numbers it: consumed 2.5x more tokens, was less accurate (95% vs. 100%), and slower.

You can see the Malloy models that were built autonomously and the full experiment details in our repo. There are examples of the validation scaffolding and instructions we added to our harness to provide semantic model design feedback to the agent and teach even the frontier models more about Malloy.

We chose Malloy for a variety of reasons, including its symmetric aggregation capability, which correctly calculates summary metrics like averages even across joins that multiply your row count. We also valued its completeness of vision (as Gartner might say!). Malloy has an elegant design that handles the edge cases that you encounter when battle testing with real users. Another key factor was that Malloy is open source. Malloy also is more composable than SQL, making Malloy views more reusable than SQL ones. Part of our hypothesis was around reusability increasing efficiency.

The Findings

We learned a few things directly from this:

• AI could generate our semantic layer. No need to learn yet-another-query-language!
• The ability to compile and validate Malloy improved accuracy substantially
• The generated layer could be evaluated against known questions and answers.
• We could discard the semantic layer, improve our harness, and generate a new layer (we even did this many times per day). AI made that possible.
• The semantic layer did not provide the expected retrieval advantage.

But there are also some implicit learnings from this that we think are much more interesting than “just the facts.” Once intent and evaluation are explicit, implementation artifacts (i.e. the semantic layer itself) become disposable. This is not a critique of Malloy! It is an observation about all of software in the AI era.

As such, the cost of regeneration becomes more important than the cost of maintenance. The result of this line of thinking is that the semantic layer shifts from being “the ultimate source of truth” to a mere projection of business behavior, with the actual durable representation of expected business behavior remaining as question-and-answer pairs. If code becomes cheap, nearly free to write, so shifts the representation of what really matters to our business.

In short, your data tests become more valuable than your semantic layer.

While this experiment does not prove that all software can or should be regenerated, it does show that when we can target specific behavior and evaluate the results quickly, regeneration becomes practical (and maybe even preferred).

Analytics in the Era of Cheap Code

Given how cheap and fast it is to (re)generate code, it is time to reconsider how we approach the problem entirely. In the old world, we would implement decisions in code, then preserve, maintain, and patch time after time, accumulating historical behavior inside the artifact. In the new world, we are not subject to the same constraints. This means we can start with capturing expected behavior and then use AI to generate a sufficient implementation. When the new models come out, we can simply regenerate it.

The linchpin that makes this possible is keeping evals alongside every expected behavior. Our semantic layer no longer needs to be a precious, slowly accumulated artifact, but instead a replaceable output of a more durable system. That system can be better aligned to the actual questions the business needs answers to.

In our testing, we had two inputs that are provided as part of the eval set: (1) a manual describing the data and the system, and (2) a collection of questions and expected answers. Given these two pieces of information as a foundation, we could regenerate a framework for answering questions into an arbitrary language (in our case, Malloy).

Said another way: we build a system that could recreate a semantic model given a solid foundation. The output artifact itself was transitory: we could create a reliable semantic layer from any number of frontier models given the same inputs.

Preserving Context

This doesn’t mean that code is no longer important. It often contains years of valuable decisions and edge cases. But we would argue that code may no longer be the ideal place to preserve intent. If the same behavior can be reproduced in another implementation (see the Bun rewrite in Rust), the underlying intellectual property did not disappear with the original code.

The durable thing to preserve is the behavior of the organization. The implementation is merely one expression of that behavior. Of course, question-and-answer pairs are not necessarily the entire durable representation - they are just a useful intermediate that makes expected behavior concrete and measurable.

What we are really getting at here is that question-and-answer sets become a starting point for organizational memory. When organized into business capabilities, intents, and dependencies, this creates a map of organizational behavior that helps AI (and humans) immediately understand the business. This parallels software development as well: effective testing is critical, but so are design docs and documented coding standards.

Given this map, our agents can cleanly retrieve the right context for a given problem. In MotherDuck for example, we provide context right next to your data with Guides so that our MCP can answer your questions more accurately over time. This beats software as built today on nearly all counts - which is optimization for execution, not understanding. By treating the software as transitory, we gain understanding of a record of decisions and a way to retrieve them in an understandable way.

So what is a semantic layer for?

If SQL based context and metrics are more accurate than the semantic layer, do we need it any more? Our experience leads us towards yes - but what you need it for can be very tightly confined to three core reasons.

First, you need a way for the data platform team to modify the underlying data models without breaking all downstream consumers. A semantic layer is a valuable abstraction above tables (far more flexible than database views) where a change can be made in the data layer without disrupting consumers.

In contrast, the second need is a way to make a single update to a metric effectively push down to all consumers. Sometimes you need to avoid change, other times you need to make that change universal. Accounting for the new realities of the business in the semantic layer should cause even existing reports to reflect an accurate state of the world.

Lastly, the guardrails a semantic model provides allow a central set of data or domain experts to have more control over customer answers. If an agent is constrained to writing queries against pre-existing semantic model definitions, it provides more determinism in how metrics are calculated. It allows one part of the organization to take on more of the complexity burden from consumers. The experts, whether engineer, analyst, or executive, can make analytics more consistent for the rest of the company.

Taken together, a semantic layer’s value comes from what it enables operationally, not from being the final repository (single source of truth) of organizational intent.

Thoughts About Implementation

Given these results, we should design our data processes very differently.

Where do we get all these questions?

If the semantic model can be generated, organizational effort can shift to codifying the business expectations of that model. That could mean manual question and answer development, but going all the way down that road looks suspect. Just look at Meta putting their engineers to work doing data labeling - it likely had many negative downstream consequences. Manual labeling may be suitable to start, but in a “do things that don’t scale” way to bootstrap the process.

Perhaps authoritative answers can be passively ingested. This has some challenges in existing systems - often a database only sees the SQL query, not the true question. But any text to SQL interface could log this information easily. Except, how do you know the answer fulfilled what the asker requested? Are we documenting slop?

As in many things in AI, a balanced approach that combines what AI is best at with human expertise looks most promising. If your business users are chatting with a Slack bot (perhaps even a QuackBot Slack Bot) to get answers, maybe the best path is a feature to certify a correct answer. The secret sauce could be an emoji! If your organization lives in Claude, maybe that looks like an MCP that looks for data questions and suggests saving the answer centrally. The devil is in the details though - every question should be time scoped so it stays an effective, static test.

Semantic Layers Need Context Too

Organizational knowledge beyond SQL queries matters as well. When a system is being designed, be that an inventory management process or a new mobile app, the design decisions of that system affect how to analyse its outputs. There are many facets to those decisions that can be documented:

• The expected behavior
• Representative examples
• Important edge cases
• The decision and rationale
• The owner (named person)
• The systems that implement it
• An evaluation that determines whether the behavior is preserved

Are you the domain expert? Documenting what you know can help you scale your impact across the company. Know an expert? Interview them, transcribe it, and give them the credit when you teach their wisdom to the whole org.

Documenting system design assumptions has substantial precedent in software engineering as well. As one example of many, the Behavior-Driven Development approach of tools like Cucumber.io directly relates user stories to test cases. Do user stories have a bad reputation? Yes. Done poorly, they take time and don’t add value. But maybe AI changes the equation. Our experiment shows that these approaches are now viable in data modeling. You can “compile” your data tests into the semantic model itself, with the fuzzy compiler of an agentic loop.

What About Existing Enterprises?

A large complex enterprise cannot simply replace its systems with a folder of specifications and ask AI to regenerate everything. After all, they have thousands of employees, tightly coupled workflows, regulatory requirements, legacy IT systems, and operations battle tested over years of work. Telling an enterprise to “extract the intent and regenerate the software” is simply naive. The pathway is not “how do we rewrite the last twenty years of software?”. Instead:

“Where should we accrue knowledge?”

Starting with the next decision, instead of a rework, means systems can continue to operate while the center of gravity shifts towards the organizational memory provided by context. Over time, more implementations become projections of explicit behavior instead of standalone code, naked without context.

Store Intent, Not Just Code

For years, data teams have accumulated code because code was the most precise way to preserve how a business worked. AI does not make that history irrelevant, but it may give us a better set of primitives to store intents. This changes the long term asset from being the implementation of the intent into the explicit, testable description of the behavior we want to preserve.

The question that remains: If you were founding your company today with AI as a given, would you choose code as the primary long-term memory of how the business works?

The barrier to entry for building full featured apps shrinks by the day, but larger datasets still don’t work by default. What if your app idea needs to analyze millions to billions of rows on the fly? How can you easily fetch and load that data into your database? Plus, how can you make sure your beefy data processing compute scales back down to zero whenever your app is idle?

Combining MotherDuck and Replit is a simple way to build and deploy with just a few prompts, but still scale up to the size of data your app needs. The key thing is that it is easy. In 3 prompts, I vibe coded a working web app that analyzes 10’s of millions of rows. Oh, and in those same 3 prompts it also created a MotherDuck account from scratch, retrieved and stored all that historical data, and set up live API queries from the app as well. Zero to data app in a couple of minutes!

Check out our prior post in this series all about using Vercel V0 with MotherDuck.

Here is a live view of my app after a few more prompts to fine tune the look and feel! What are the chances you get stuck in the airport on your next flight?

Replit: From Idea to App

Replit is a tool for building apps with an AI agent. It sounds simple, but apps have many moving parts! Replit smoothly handles both development and deployment, including things like authentication. A key value of Replit is that just about anybody can build an app now with Replit in their toolbox. It also has a Design mode so that you can tweak and customize with the keyboard and mouse for those kinds of changes that are hard to describe in a chat.

By default, Replit uses Postgres, but with another sentence in your prompt it can happily use just about any database! MotherDuck is an analytical database (Postgres is transactional), which means that MotherDuck excels at things like reporting queries that summarize large amounts of data as well as bulk loading. Since MotherDuck has a Postgres compatible API option, Replit’s agent was able to use it very naturally. MotherDuck’s SQL syntax is also 99% Postgres compatible, so the agent could write the SQL on our behalf as well.

Using Replit and MotherDuck Together

Follow this recipe to be building data apps in no time!

1. Create a Replit Account

   1. There is a free tier for testing
   2. This does take a human though

2. Ask Replit or your agent to create a MotherDuck account

   1. Your agent can start without a credit card, then you can claim your account via email when it’s time to go to production

3. Tell the agent to load data into MotherDuck with a Flight

4. Ask for a Replit web app, backed by MotherDuck!

5. Tweak the look and feel with a few prompts or manually adjust with Replit’s Design mode

6. Click to deploy to production

To build something similar to the flight delay tracker I put together, try a prompt like:

Sign up for MotherDuck (https://motherduck.com/blog/agent-signup/). 

Load 5 years of historical data using a MotherDuck Flight:
* Flight delays from BTS Airline On-Time Performance data. Ex: (https://transtats.bts.gov/PREZIP/On_Time_Reporting_Carrier_On_Time_Performance_1987_present_2025_1.zip)
* Weather forecast history by airport with the Iowa Environmental Mesonet (IEM) ASOS/METAR archive. Ex: (https://mesonet.agron.iastate.edu/cgi-bin/request/asos.py?)
* US holidays. Ex: (https://date.nager.at/api/v3/PublicHolidays/2025/US)

Create a web app on Replit that is backed by MotherDuck for 
exploring airline flight delay data and predicting delays.

Pull live weather data from the national weather service API.

Predict a user's delay by flight/route, holiday status, and current weather.
Also show a map of flight routes and a histogram of historical delays.
Let me filter by departure and arrival airport, carrier, and flight.

Make the layout mobile and touch friendly.

I enjoyed Replit’s design features in particular. I was able to make manual tweaks, or just click on a part of the app to give to the agent as context. That way there was no more explaining exactly which section I was talking about. My workflow became: click on part of the app, then ask for the tweak I was looking for. The design feature also includes a lot of templates and ideas for customization:

I also had good success using even a lightweight model like GPT 5.6 Luna on max effort. We have previously found Luna max to be very efficient for analytics!

Of course, publication to a custom URL of my choice was a single click. It comes with autoscaling by default too.

It is very convenient for Replit to offer a free tier as well! MotherDuck lets you get started for free too (we have a Lite plan that starts at $0). Your agent can sign up for that free MotherDuck account with a dedicated agent endpoint, continue its testing, and then you can claim that account with a few clicks and an email verification. No need to hand your agent a credit card!

MotherDuck Flights also made it super simple for Replit to load all that historical data. I didn’t want to pull that on every page load, or load it into a transactional database that isn’t designed for things like bulk loads or full table reads. Flights are a serverless Python runtime with full access to any Python library, so anything Python can do, you can do on a Flight! It also has full internet access so you can download or scrape data from anywhere. Since it is serverless, it only pops into existence when you need to load data and costs nothing when you aren’t using it. It also means you don’t need to sign up for another tool - it’s built into MotherDuck.

All told, you get a fully serverless, scalable data app that you can test out for free and put into prod just as easily.

Time to Vibe Code it Up!

With a couple of clicks and prompts, you can have a data app fully deployed into production. Give MotherDuck and Replit a try! Just ask your agent.

Thousands of apps are vibe coded every day, yet enterprises still struggle to see value from AI. Often the gap between prototype and production is too wide a chasm. Combining Vercel V0 and MotherDuck narrows that gap to a few minutes. V0 brings the joy of rapid prototyping in an agent chat. MotherDuck makes data ingestion seamless while scaling to larger datasets. Your agent can even sign up for MotherDuck for you, for free! Then a prod deployment on Vercel is just one prompt away.

In a single prompt, I had a working prototype health tracking app using V0 and MotherDuck. In 10 prompts I had pulled in additional datasets (and scheduled them to re-load into MotherDuck), added some fun visuals, and even made it mobile friendly. We’ll walk through how you can build something similar (ok, mostly how your agent can do the building!).

Check it out! This is real data that Bryan Johnson publishes about himself as a part of his "don't die" philosophy. Click on a body system to see his stats:

Vercel V0: An AI Agent for Full Stack Apps

What is V0? It’s a way to build web apps with natural language. These are not just throwaway artifacts, but fully shareable web sites. You can build within V0’s chat app interface or you can use your agent of choice (Claude, ChatGPT, etc.). Hook up a database (with a prompt or two) and then deploy a backend service to Vercel’s web hosting infrastructure once you’re ready to ship. V0 can integrate with git as well to handle larger and longer term projects.

Here is a look at the Vercel V0 UI while building a different iteration of my health tracker example app (bonus points if you can spot my typo...):

My favorite part about V0 is just how easy it is to build a real web site that I can send someone a link to. Sometimes I really love this timeline!

What are Data Apps?

For a real app, you’ll need a place to store data from your users. In other words, you need a database. That’s what sets an app apart from just a consumption-only web site! Frequently, apps are powered by databases that are focused on transactional workloads, however, some apps are not a great fit for that type of db. We tend to call those “data apps”.

Some apps with heavier and more analytical workloads are ones that include some kind of dashboard experience. Your company may want to provide an analytics experience embedded within your application. One style of data app I see commonly is a health tracking app, which inspired my example. Bryan Johnson is wild enough to post his own health data online (I sure won’t!), so it is a nice example of what we could build for ourselves or for customers.

Another example that I experience every day is my banking app. Your bank’s app likely shows you a trend of your purchases over time with ways to slice and dice by category. It might even detect anomalies and give you recommendations for how to save money. Those workloads take a lot of analytical horsepower and can be painfully slow on a transactionally focused database.

Your company may have (or want to have!) internal apps for comparing data across systems or making business processes more automated. Forecasting and scenario planning is another area where the combination of interactivity and data processing horsepower is critical. Geospatial analytics also often contend with large datasets. “Show the restaurants near me” is actually a heavy calculation!

In summary, a data app is one that needs to analyze a large amount of data to give an answer, not just retrieve a few rows from a specific user.

The V0 and MotherDuck Combo

These steps are all it takes to build a data intensive app. It really can be this easy!

1. Create a Vercel account

   • There is a free tier for testing
   • This does take a human though

2. Ask V0 or your agent to create a MotherDuck account

   • Your agent can start without a credit card, then you can claim your account via email when it’s time to go to production

3. Tell the agent to load data into MotherDuck with a Flight

4. Ask for a v0 web app, backed by MotherDuck!

5. Tweak the look and feel with a few prompts

6. Ask to deploy to prod on Vercel

For example, here is a starting prompt to build something just like the health tracking app I built:

Sign up for MotherDuck (https://motherduck.com/blog/agent-signup/). 

Build a MotherDuck Flight that pulls health data on Bryan Johnson 
(the person trying to live forever) and load it into MotherDuck. 

Then create a web app on Vercel v0 that is backed by MotherDuck 
that visualizes Bryan’s health over time. 

I want a da Vinci style (but G-rated) human drawing interactive visual 
where I can zoom in and out to get details about various body systems. 

When I click on one, I want to see a dashboard in another panel that 
shows indicators, trends over time, and comparisons with average humans.

Make the layout mobile and touch friendly.

It takes a lot of pretty cool engineering behind the scenes to make that feel so seamless!

Vercel is famously ergonomic for web hosting (it took me just one afternoon to feel productive - wild times!), and it is so efficient that it is able to offer a hobby tier.

Similarly, MotherDuck is more efficient than any other data warehouse, which allows us to offer a Lite plan that starts at $0. We also recently added a dedicated endpoint for agents to sign up to make it even easier to get started. You really want that combination though: both the agent friendliness and the risk-free starting price.

MotherDuck is available in the Vercel marketplace, so it is supported natively and v0 knows where to look for the details. This uses MotherDuck's Postgres endpoint that allows any Postgres driver to talk to MotherDuck.

MotherDuck Flights also really make it easy to bootstrap your app and get started. Flights are a serverless Python runtime with access to any Python library, so anything Python can do, you can do on a Flight! It also has full internet access so you can download or scrape data from anywhere. Since it is serverless, it only pops into existence when you need to load data and costs nothing when you aren’t using it. It also means you don’t need to sign up for another tool - it’s built into MotherDuck.

MotherDuck can keep running at high speed even if that data scales up to billions of rows. Data can really add up over time, especially if you are surfacing information about how your users use your platform back to them. Web event data or agentic log data are some of the largest datasets that most companies have and users are very interested in them!

Finally, Vercel is a great choice for a production web application. It includes all kinds of advanced features for even high traffic web sites. V0 makes it easy to build on top of that solid foundation and leave the devops to someone else!

Happy Building!

With a couple of clicks and under 10 prompts, you can have a data app fully deployed into production. Loading even large amounts of data is just as easy (simply request a Flight!) and your app will keep humming along well into the billions of rows. MotherDuck makes it really seamless to get started, even for our machine friends.

Give MotherDuck and Vercel a try - just ask your agent!

I hope you're doing well. I'm Simon, and I am happy to share another monthly newsletter with highlights and the latest updates about DuckDB, delivered straight to your inbox.

In this August issue, I gathered the usual 10 updates (+2 bonus) and news highlights from DuckDB's ecosystem. Please enjoy reading about giving agents their own databases, having a single database connection that grants access to over 30 external DBs, a sneak peek into the upcoming v2 async feature, and how DuckDB is used for graph analytics and as a data layer for multiple tools.

To Every Agent Its Own Database

TL;DR: Joe proposes an agent-native architecture where each agent leverages its own embedded DuckDB instance for direct, peer-to-peer analytical data exchange, moving computation closer to the agents.

Joe explored an alternative to centralized data platforms for AI agents by giving each agent (peer) a dedicated, embedded DuckDB instance using Quack. Quack peers communicate directly via loopback TCP ports, exchanging "immutable analytical slices". Each slice is uniquely identified by a SliceRef dataclass with catalog_id, dataset, DuckLake snapshot_id, a contract_digest of its Malloy-defined semantic model, and a slice_digest. This approach decentralizes computation and analytical state, addressing concurrency and rapid chaining of results in agent workloads.

One bonus article as related: Martin wrote about Your coding agent keeps a diary, with a separate DuckDB for AI with dlt extraction.

Announcing the DuckDB ADBC Extension

TL;DR: The new DuckDB ADBC extension enables DuckDB to connect directly to over 30 external databases via the Arrow Database Connectivity (ADBC) API, leveraging Apache Arrow for efficient data transfer.

Sam explained that this extension offers a unified interface to systems like Snowflake, Databricks, and PostgreSQL, moving beyond individual vendor extensions. It utilizes Apache Arrow for fast, zero-copy, columnar data transfers, bypassing the performance bottlenecks of row-based APIs. Users can execute queries directly with read_adbc('profile://mydb', 'SELECT * FROM games') or use ATTACH 'profile://mydb' AS mydb (TYPE adbc) for persistent connections supporting SELECT, INSERT, COPY, and CTAS. ATTACH currently lacks predicate and projection pushdown, requiring read_adbc for optimized large dataset operations, but this is a planned enhancement.

Asynchronous I/O in DuckDB: Work, Thread, Work

TL;DR: A big one for the upcoming DuckDB v2.0 (Fall 2026), introducing asynchronous I/O for Parquet and CSV files, significantly improving query performance by better utilizing remote storage bandwidth.

Pedro explains the implementation involves separate REGULAR worker and ASYNC I/O thread pools (up to 256 threads), coupled with a read-ahead queue and asynchronous memory governance to proactively fetch data and prevent out-of-memory issues. Benchmarks show dramatic speedups such as TPC-H Q6 SF100 on S3 with Parquet improved 3x (from 8.23s to 2.84s), or saturating network bandwidth, while CSV queries saw a nearly 20x speedup (from 878s to 45s), even under concurrent workloads and memory constraints.

Webduck: A self-hosted DuckDB-as-a-Service server with REST API and Web UI

TL;DR: WebDuck is designed for web hosting providers who want to offer their customers a ready-to-use administration interface for DuckDB databases and data analytics out of the box, just like the database admin tools that come with any hosting package.

As the name says, Webduck provides a UI with an overview dashboard, projects, and browsing views. It implements a DuckDB storage engine with per-file reader-writer locks to ensure safe concurrent access, aligning with DuckDB's single-writer model. Mike, the creator, highlighted the offloading of blocking engine and auth calls to a threadpool via asyncio.to_thread in api/db.py and api/admin.py.

duckdb-gql: An extension to run graph queries and algorithms using ISO GQL

TL;DR: DuckGQL, a C++17 extension, integrates a growing ISO GQL subset into DuckDB, allowing graph pattern queries and mutations with DuckDB's native relational storage and execution engine, and provides an explicit CSR layer for graph algorithms.

DuckGQL leverages typed vertex and edge tables, supporting bulk import and GQL operations. The extension uses dynamically built, connection-local CSR projections for algorithms, automatically invalidated by mutations, and property indexes utilize native DuckDB ART indexes, extending DuckDB's capabilities for direct graph analytics.

Perspective 5.0.0 featuring DuckDB pushdown

TL;DR: Perspective, a visualization and analytics component for large and/or streaming datasets, ships a DuckDB Virtual Server in v5.0.0 that replaces its built-in query engine with pushdown SQL, so <perspective-viewer> drives DuckDB directly instead of ingesting data.

It adds DuckDBHandler, a VirtualServerHandler implementation for both Python and browser duckdb-wasm. ViewerConfig options like group_by, filters, sorts and expressions are translated into SQL, with results read back via Apache Arrow IPC. Because DuckDB owns the query layer, its aggregates and expression syntax surface in the UI rather than perspective-server's: Andrew's screen recordings show 6mm rows from NYC Open Data and native time_bucket used inside the Column Expression Editor to build time-series bins. NYC Open Data Demo, Browser demo.

DuckDB Internals: Why is DuckDB Fast? (Part 2 Vectorized Execution)

TL;DR: Kyle follows up on his highly shared Part 1, highlighting that DuckDB's vectorized execution processes data in 2048-row batches, reducing function call overhead and improving CPU IPC over the row-at-a-time Volcano model.

Key elements include DataChunks and four Vector types (Flat, Constant, Dictionary, Sequence), unified by a UnifiedVectorFormat for streamlined operator logic and delayed materialization. Filters leverage selection vectors to avoid data copying. Kyle explains how DuckDB is using interpreted execution with precompiled functions, optimizes inner loops with validity masks and C++ compiler-driven SIMD. The transition to a push-based execution model enhances parallel processing, enabling independent pipelines for sources, operators, and sinks, crucial for UNION ALL.

datafusion-ducklake-provider

TL;DR: A Rust crate that enables Apache DataFusion to interact with DuckLake tables via various catalog backends, including SQLite, DuckDB-file, Postgres, and client-only DuckDB Quack transports.

The core integrates as a DataFusion TableProvider and catalog provider, facilitating WRITE, DELETE, UPDATE, and maintenance operations. Developers can leverage the DuckLakeSessionContext to execute DuckDB-shaped SQL commands like ATTACH 'ducklake:sqlite:metadata.sqlite' AS lake (DATA_PATH 'data/') for seamless DataFusion integration with DuckLake catalogs.

Developer Dad Does Disney: Vacationing in the Personal Software Era

TL;DR: Example of how to use MotherDuck's MCP, Dives, and Flights to build a personal Disney World ride planner, dynamically integrating live and historical data for optimal decision-making.

Alex detailed how remote MCP-enabled AI agents, like Claude, can orchestrate database operations and app construction. Data was fetched from live APIs using read_json for parallel querying across park endpoints.

Historical wait times were regularly refreshed via a MotherDuck Flight, the new agent-native data pipeline. The solutions provide a live ride-and-show planner and a live ride planner. Check out the blog above if you go there or want to see how these look and how to build your own for another open API you have access to.

Self-hosting DuckDB: the road to production

TL;DR: Self-hosting DuckDB scales from local to cloud, but each step adds operational complexity, especially for concurrency and persistence.

Mehdi highlights a practical map for self-hosting DuckDB, detailing the increasing operational "boxes" at each stage. An initial local setup on NVMe is the fastest, but moving data to S3 introduces network bottlenecks and authorization overhead. Scaling compute to the cloud (e.g., EC2) can mitigate this, and distributed queries can be achieved via fan-out with Lambda functions for partial GROUP BY and SUM/COUNT. For concurrent readers, dedicated compute per user flattens tail latency, while DuckDB-WASM pushes compute to the browser. He mentions that many writers require either the new quack_serve protocol for serialized writes or a DuckLake setup with a managed Postgres catalog for ACID transactions.

His core takeaway is to self-host, but don't accidentally build a database company.

Beyond Copilots: We're Building a Data Stack Live with AI Agents

2026-08-18. h: 08:00. Online

Do AI Agents Need a Semantic Layer?

2026-08-26. h: 09:00. Online

Time Travel & Schema Evolution: DuckLake Handles Change

2026-09-03. h: 09:00. Online

dbt Summit

2026-09-15. h: 09:00. Las Vegas, NV

Big Data London

2026-09-23. h: 09:00. Olympia, London, UK

With our new signup API, an agent can provision a MotherDuck account, build a data pipeline using our hosted Python runtime (Flights), run sub-second analytical queries, and visualize results (Dives). All this, of course, in addition to the flexibility and power of using local DuckDB.

Our friends at dlt have been testing the signup API, using an agent to connect dlt pipelines to a MotherDuck warehouse. Co-founder and CEO Matthaus Krzykowski says: “The part we liked most is what the API doesn't give the agent: no credentials, no shell, no network. So an agent only ever writes the dlt pipeline logic - MotherDuck's create-account API handles provisioning a real warehouse and owns everything sensitive.”

Join us, dlt, and Lightdash on August 18 as we build a working data stack live with AI agents – ingestion, warehouse, and BI. Save your seat →

Get started by asking your agent to: Fetch https://new.motherduck.com – batteries included.

Here’s an example of how it works!

From prompt to warehouse

Let’s start in a new agent session. We’re using Claude Code here on auto mode, but any common agent harness will work similarly – Mehdi’s companion post replays a full agent session step by step.

“Fetch new.motherduck.com and get yourself a data warehouse. Query yesterday's GitHub star events from GH Archive – which AI agent frameworks are trending?”

The agent accesses a webpage with markdown-formatted instructions to send a POST request: curl -X POST https://new.motherduck.com. The request itself is simple and empty: no headers, body, or auth. The request returns a JSON object with the following fields:

• motherduck_token: a read/write token for the new MotherDuck organization
• claim_org_url: a one-time-use URL for a human user to claim the organization
• how_to_use_motherduck: a plain-text quick start guide
• region: the cloud region of the new organization (aws-us-east-1 only for now)

With the prerequisites and some instructions, the agent can get to work: stashing the token and connecting to MotherDuck using the DuckDB CLI as a thin client. Of course, we’ll need to rotate our token before getting anywhere near real data, as the agent has accessed it directly.

Then, our agent can start fetching our data. After exploring GitHub public APIs, a CTAS query against GH Archive can create a table of GitHub star events. On a Pulse duckling (MotherDuck’s smallest compute instance), it takes about three seconds.

CREATE OR REPLACE TABLE star_events AS
SELECT
  id AS event_id,
  repo.name AS repo,
  actor.login AS actor,
  created_at::TIMESTAMP AS starred_at,
  date_trunc('hour', created_at::TIMESTAMP) AS hour,
  repo.name IN ('browser-use/browser-use', 'openai/codex',
    'anthropics/claude-code' /* + 5 more */) AS is_agent_framework
FROM read_json(
  ['https://data.gharchive.org/2026-08-04-0.json.gz',
   /* ...22 more hourly files... */
   'https://data.gharchive.org/2026-08-04-23.json.gz'],
  columns={id: 'VARCHAR', type: 'VARCHAR',
           repo: 'STRUCT(id BIGINT, name VARCHAR, url VARCHAR)',
           actor: 'STRUCT(id BIGINT, login VARCHAR)', created_at: 'VARCHAR'},
  format='newline_delimited', compression='gzip', ignore_errors=true)
WHERE type = 'WatchEvent';

Simple, but handy! We’re clipping a bit here for brevity, and not trying to fetch everything, but you get the idea.

The analysis was just as quick – star totals, hourly velocity, and peak hour in a quarter of a second:

SELECT repo,
       count(*) AS total_stars,
       round(count(*) / 24.0, 3) AS stars_per_hour,
       arg_max(hour, cnt) AS peak_hour,
       max(cnt) AS peak_hour_stars
FROM (SELECT repo, hour,
             count(*) OVER (PARTITION BY repo, hour) AS cnt,
             is_agent_framework
      FROM star_events)
WHERE is_agent_framework
GROUP BY repo
ORDER BY total_stars DESC;

┌─────────────────────────────────────┬─────────────┬────────────────┬─────────────────────┬─────────────────┐
│                repo                 │ total_stars │ stars_per_hour │      peak_hour      │ peak_hour_stars │
│               varchar               │    int32    │  decimal(4,3)  │      timestamp      │      int32      │
├─────────────────────────────────────┼─────────────┼────────────────┼─────────────────────┼─────────────────┤
│ firecrawl/firecrawl                 │           8 │          0.333 │ 2026-08-04 06:00:00 │               2 │
│ Panniantong/Agent-Reach             │           4 │          0.167 │ 2026-08-04 08:00:00 │               2 │
│ TencentCloud/TencentDB-Agent-Memory │           4 │          0.167 │ 2026-08-04 17:00:00 │               1 │
│ obra/superpowers                    │           4 │          0.167 │ 2026-08-04 07:00:00 │               1 │
│ farion1231/cc-switch                │           3 │          0.125 │ 2026-08-04 00:00:00 │               1 │
│ browser-use/browser-use             │           2 │          0.083 │ 2026-08-04 03:00:00 │               1 │
│ openai/codex                        │           1 │          0.042 │ 2026-08-04 10:00:00 │               1 │
│ anthropics/claude-code              │           1 │          0.042 │ 2026-08-04 14:00:00 │               1 │
└─────────────────────────────────────┴─────────────┴────────────────┴─────────────────────┴─────────────────┘

Building agent-driven data pipelines

The one-time CTAS is great, but what if we wanted to append fresh data each day to inform our analysis? With the MotherDuck token in hand, we can direct the agent:

“Package that query as a Flight so we can re-run it on MotherDuck.”

Flights are Python programs that run on MotherDuck's hosted runtime, on demand or on a cron schedule. You can run virtually any pip-installable Python code. Here, the agent wrote a few lines of Python around the same SQL – tweaked to append only the hours it hasn't seen yet – and registered it with the token it already had. The agent is using the DuckDB Python client here, but could just as easily refactor to use dlt or another Pythonic framework.

MotherDuck injects credentials into the Flight at runtime, so the agent writes the logic and never touches a secret:

# main.py – runs on MotherDuck's hosted Python runtime
from datetime import datetime, timedelta, timezone
import duckdb

def main():
    con = duckdb.connect("md:")  # token injected at runtime
    last = con.sql("SELECT max(hour) FROM my_db.star_events").fetchone()[0]
    urls = gharchive_urls(since=last)  # every complete hour we haven't ingested yet
    con.execute(f"""
        INSERT INTO my_db.star_events
        SELECT id, repo.name, actor.login, created_at::TIMESTAMP,
               date_trunc('hour', created_at::TIMESTAMP), repo.name IN (...)
        FROM read_json({urls}, ...)
        WHERE type = 'WatchEvent'
          AND id NOT IN (SELECT event_id FROM my_db.star_events)
    """)

if __name__ == "__main__":
    main()

One run later: exit code 0, ten seconds, 797 new star events appended. And if we want it running every day instead of on demand, scheduled Flights are available on the Business plan.

Once we’re ready to persist our work, or share data with a colleague, we can access the claim_org_url to take ownership of the agent’s MotherDuck organization. Total human effort: three short prompts and one email address.

Happy (agent) querying!

The warehouse was MotherDuck, which I work on, so weigh the product parts accordingly. The bit I actually want to talk about is more general. Agents can now provision real infrastructure by themselves, and that quietly breaks something.

What it breaks is your ability to say what happened. Codex, Claude Code, the web chats, they all stream a wall of tool calls at you. Somewhere in there a database got created, a pipeline ran, a query scanned 40GB. Good luck reading that back an hour later.

So this post has two halves. First, why free tiers are going agent-first, with the curl commands to prove it. Then how I replayed everything my agent did, using our experiment at motherduck.com/try.

Wait, agents can spawn services without me paying?

The free tier has always been there for humans, but there was a transaction attached: give me your email, I'll give you a sandbox. That email was the whole point. It's how a SaaS company turns a trial into a sales pipeline.

With agents, that transaction falls apart. The agent is the interface now, and it doesn't have an email. It doesn't want to run an OAuth flow, click a verification link, or read your onboarding modal. So a bunch of companies did the obvious thing: drop the signup, hand out a token, and let a human claim the account later if they like what got built.

A few you can try right now:

A transactional DB for your app, Postgres, with Neon

# Create a transactional DB for your app, Postgres
curl -X POST https://neon.new/api/v1/database \
  -H 'Content-Type: application/json' \
  -d '{"ref":"my-app"}'

No auth. You get a connection string back. It expires in 72 hours unless you claim it. Same machinery sits behind Replit, v0 and Netlify DB, where a database just appears and nobody ever said the word "Postgres" out loud.

An email inbox with AgentMail

# Create an email inbox for your agent
curl -X POST https://api.agentmail.to/v0/agent/sign-up \
  -H 'Content-Type: application/json' \
  -d '{"human_email":"me@example.com","username":"my-agent"}'

Also no auth. You get back an organization_id, an inbox_id (my-agent@agentmail.to) and an api_key, and from there the agent can send, receive, thread and reply from its own address.

This one keeps a human closer to the loop than the other two. I ran that curl against my own address and the 6-digit code showed up in my inbox right away. Until the agent posts the code back to /v0/agent/verify, the new inbox can only send mail to that same human. So the agent gets a real address in one call, but it can only talk to the person who owns it until they say yes once.

An analytics database with MotherDuck

Which is the rest of this post.

One POST and you have a warehouse to answer questions

# Create a MotherDuck account for your agent
curl -X POST https://new.motherduck.com

There's no body and no auth header. You get back:

• motherduck_token to connect
• claim_org_url for the human, later
• region, the account's region
• how_to_use_motherduck, a small guide for your agent on how to use MotherDuck

The endpoint creates an anonymous org on our Lite plan, owned by a service account until someone claims it. Same limits as any Lite org, and no credit card involved. From there the agent can:

• ingest data
• run queries on DuckDB in the cloud
• store data in cloud storage and query it over the network
• build pipelines with Flights (Python)
• build interactive apps with Dives (React on top of live queries)

When you want to keep it, open claim_org_url, sign in, and the org is yours with everything the agent built still sitting in it.

One caveat worth knowing up front: a claimed org can't be merged into an org you already have. So if you're already a MotherDuck customer, treat this as a scratch org.

Fine, but what did it actually do?

That's the signup half solved. The visibility problem is still open, and that's what we built motherduck.com/try for.

Fair warning: /try is an experiment rather than a supported product surface. We built it because watching an agent work on MotherDuck explains the platform better than any feature page, and there was nowhere to do that.

It runs the same agent loop, except every service it touches shows up as something you can click. No signup. Pick ChatGPT or Claude as the model, then start from one of the example prompts, point it at any public S3/https parquet or CSV URL, or upload your own csv/parquet file.

You don't set anything up for this. No API key, no agent of your own to wire up, no MCP config. That's also why each session comes with a cap on messages: /try is somewhere to explore, not somewhere to do your Tuesday work. When you want the day-to-day version, point your own agent at the MotherDuck MCP server instead and you get the same tools inside whatever client you already use.

Here's the prompt I gave it:

Four things worth watching in that run, and all four are clickable.

1. It figures out the schema itself. GHCN-Daily is not a friendly dataset. It's narrow, one row per station per element per day, with the measurement type hidden in a column instead of the schema.

2. It writes a Flight. Once it decides this needs a real ingest and not a one-off query, it packages the Python.

3. It runs the Flight and you get the logs. Both runs are listed, the failed one and the green one, with output you can read. You can't get that out of a chat transcript.

4. It builds a Dive. React on live queries, so the chart is hitting the warehouse rather than a CSV it pasted into memory.

And the full live demo end-to-end:

Hand the run to someone else

Everything above is you watching your own agent. The bit I care about more is that you can share a session and let someone else replay it.

They open a link and step through the same run: the exploration queries, the Flight, the logs, the Dive. No screen recording, and nobody sits waiting for the agent to redo the work. An agent run becomes something you can review.

Why you should bother looking

The agent will be confidently wrong about a join or a filter at some point, and reading the generated SQL is the only way you catch it. On this run the decision worth checking was statistical rather than mechanical.

Put the logs and the Dive side by side. The logs report Belgium going from 8.35°C in 2015 to 11.92°C in 2024, so +3.57. The Dive puts Belgium's trend at +2.68 per decade. Those disagree because the agent declined to report the raw endpoint difference and fitted a trend instead. That's the right call, and its own KPI cards show why. 2015 is the coldest year in the window at 8.3°C and 2022 the warmest at 12.2°C, so anchoring on 2015 makes every country look like it is boiling.

The bar chart is honest in the same way. Hungary and Finland sit near zero, which is what a ten-year window looks like when the signal is smaller than the noise. A worse pipeline would have quietly smoothed those into the story.

Ten years is a short window for climate claims either way, and this post is really about the plumbing. The point is that I could check the arithmetic in about a minute, by opening the Flight and reading the logs next to the chart.

There's a more selfish reason too. Watching Flights and Dives get created is how you find out what the platform can do :)

Try it

motherduck.com/try, no email needed. If you like what your agent built, claim the org and keep going.

In the meantime, take care of your agents and... your ducks of course.

When OpenAI slashed the price of GPT 5.6 Luna by 80% this week, we noticed it immediately in our evals. At first, we even thought we had made a mistake! On an agentic SQL benchmark (see our prior results here), Luna on max effort displaced Gemini-3-Flash on low as the reigning champion, maintaining 99.8% accuracy, at a 5x lower price point. In a semantic modeling benchmark, costs dropped even further, getting 10x cheaper than last week’s Luna! We believe model caching improvements drove that extra 2x boost.

We’ll share details on that semantic model benchmark in an upcoming post, but a sneak peek is here!

When Opus 4.5 landed, AI models passed a threshold where they became fundamentally more practical for professional-sized coding workloads. That same magnitude of shift just happened, but at a different spot on the Pareto frontier with GPT 5.6 Luna. Luna is great at SQL. But unlike Opus, it is also incredibly fast and cheap. Never before has generating accurate SQL been anywhere near this approachable.

We are at an inflection point. Luna with max effort occupies a brand new section of the price/performance curve. In DeepSWE, Luna sits 3% below Fable at under 1/10th the price.

How should we react?

To take full advantage of this dramatic shift of the price/performance curve, there are both small steps to take and larger shifts to make in our approach. We need to think bigger about how to apply these new faster models in the data world.

Small changes worth making

The first thing is that if you were using a large model on a low effort setting, you owe it to yourself to try Luna on max. It is just so efficient for any task that you can determine doesn’t need maximum intelligence. If you already have identified those tasks by setting your effort to low, swap that model out instead.

Another easy change is to just ask more questions. This is the Jevons Paradox in action - improvements in technology immediately lead to more applications. That could look like testing 5 hypotheses at once before hearing back from an agent, but with models this fast, iterating into deeper levels of detail becomes far easier. Maybe you pre-fetch answers to relevant customer questions rather than wait for them to pick from a list first.

Shifting our approach

Once AI is fast, the ROI of a faster and lower latency data platform jumps. In agentic workflows, the request to the LLM has long been the total time bottleneck. If one turn of the agent took 10s of seconds, the benefits of a faster database just weren’t impactful.

Analytical databases can be 1000x faster than transactional ones if your workload is analytically shaped. Many agent questions are. With this new revision of Luna, your transactional database just became your user experience bottleneck.

Likewise, if your analytical store takes 30 seconds to spin up, a low latency DB could have answered 10 agent questions in that time. Agent workloads are bursty, so a low latency serverless approach makes sense. Especially if you are designing customer facing agentic experiences, you’ll feel the difference with a responsive analytical engine now. What new product features or even whole businesses are possible once an agent can provide data driven answers at this speed?

The models are still only as good as the context they’re given. Building a context layer with all the details of your specific business or domain remains incredibly high leverage. Now though, it pays dividends to be more detailed in that context so that a weaker model can interpret it. When weak models couldn’t write accurate SQL, context just needed to be good enough for the strongest of models. Putting in that extra time documenting your domain can slash costs and speed up answers.

Your data team needs more evals

In the data world, historically our tests were data quality checks. Often we only check if easily computable invariants hold (no duplicate customer ids, no NULL order prices, every order joins to a real product id). For agentic analysis tasks, we need more than just SQL checks. We need natural language questions and the correct answer based on the data. We then evaluate if an agent can take the question and use business context and a database connection to answer it correctly.

Running those evals just got 5x cheaper.

One natural opportunity is to use those savings to run evals far more often. We can explore how each new model performs and even tune settings within models, where before perhaps we accepted the defaults from a single lab.

We could even catch cases where model intelligence fluctuates. Model performance is a function of the underlying model weights, but also the infrastructure used to serve it. As capacity gets tight, model intelligence is reduced, and a well calibrated eval system could catch that. Your business could jump to a more optimal model, whether that is in the days before a new model release or during the highest traffic times of the day.

The model is only one factor though. It is valuable to measure how each new piece of organization context helps (or hurts!). OpenAI’s own data team found that catching regressions in their context layer was a huge value of their eval framework. Running evals weekly just won’t provide enough signal to build accurate organizational knowledge.

The business itself is constantly changing too! If you add a new discount program, your agents may not be able to deduce how to calculate revenue correctly anymore. Catch those logical bugs before you share that graph to the board!

Another truism is that we need to design our eval workflows to be frontier lab agnostic. We use OpenRouter in a custom harness for our evals so that within hours of launch we can run any of the latest models from all the frontier labs. We get the most benefit in this modern AI economy if we can develop intellectual property at the harness or context layers and treat the model as a commodity. By keeping switching costs low and avoiding lock-in, we can jump to the next top model as soon as it provides a return on investment.

Revisiting our assumptions

OpenAI and the other labs have long been racing to provide intelligence too cheap to meter. For data questions, GPT 5.6 Luna legitimately looks like we’ve arrived. Now it’s time to build the systems around the model to convert raw intelligence into accurate, relevant answers to customers. Well documented context, rigorous evals, and a fast analytical engine are now the determining factors.

Luckily, Maxime Beauchemin, the creator of Airflow and Superset and the person who defined what "data engineer" meant for a decade (more on him below), joins us to show how he uses agents and what he's built for working with them. I tried to extract the patterns behind how he actually uses AI in his data work today. This is the fourth interview in 'How to use AI with DE'.

In this article, we go into four parts: (1) How to balance quality with messy data warehouse work, and how to manage agents with Figma for agents. (2) We elaborate on the future of the context layer and the return to semantics, (3) how Okta for Agents is needed for security, and (4) how the future of agentic workloads can be done in teams, whose yap-to-ship ratio is best, and why Amdahl's law still counts.

Introducing the Guest: #4 Maxime Beauchemin

Our guest in this interview is Max Beauchemin, the creator of Airflow and Superset. He's known as one of the OGs of defining how data engineering worked back in 2017, and founded Preset, the company behind Superset, and currently serves as its CEO.

He is heavily involved in the AI workflow, which is another reason I wanted to interview him for this series, but he has also been building in the space himself: Agor (Ag: AI agent + Or: orchestration), earlier tooling like claudette-cli2, and db-agents, an experiment to embed agent context directly inside databases. We'll get into it all.

Max and I talked about many things, among them how to use AI in data engineering, how security plays a role, how shared, secure, context-rich agent workspaces work within teams, and how he uses AI assistants to run his business and ease his life as a CEO.

Max is a true open-source enthusiast, and he wants open source to win. Everything we discuss here is somewhere on GitHub, which I have happily linked throughout the interview.

Figma for Agents: Visualizing Tasks and Jobs with Agor

Before we start using Figma for Agents, coordinating them on canvas, we need to ask why we need coordination and orchestration in the first place.

Balancing Quality with Quantity: Messy DWHs

That's where we started, with the challenge of messy data warehouse environments that most people find themselves in. I asked how he balances quality and quantity, aiming for high quality.

Max says that the new models, Opus 4.5 or 4.61, are not making many errors anymore and are very clever when they get the right context as above with all the database schemas of tables and data types, and even querying it with MCP. He says they almost run in self-serve mode, but he still prefers that users know what they are doing and can either read the generated code or verify the generated numbers on a dashboard or chat results.

But the setup is critical. With these three prerequisites, the agents handle almost all queries really well:

1. You need some preparation claude.md/ agents.md
2. Access to SQL (e.g., execute dbt)
3. Access to MCP or CLI for BI tools (e.g., Superset supports sup!, a CLI to interact with Superset)

The only problem, and always has been, is the messy structure and sources that most organizations have, growing from an initial small project into a certain stage. There are always obscure tables or strings, timestamps not aligned, or hidden information that is not encoded in code or written down. Or there's the hidden knowledge, like that a certain table shouldn't be used anymore or has bad data, which is known to the people using it but might not be to agents.

The Canvas in Which Your Agents Can Run: Automate Most CEO-stuff

When he recently saw the power of agentic coding, Max went all in and has been building the Figma for agents ever since. Something he can use to collaborate with agents within his company, instead of everyone running the same prompts locally and needing to sync with each other manually. That's when Agor was born.

Agor stands for Ag: agent and Or: for orchestration. As the creator of Airflow and CEO of a data company, he knows exactly how a tool needs to improve his workflow. He also called it:

The goal is to automate most of the automatable CEO-stuff

The board: branches as cards, zones as regions, agent sessions, and teammates present live. See full demo Agor [Agent Orchestration] Demo.

Building an Internal Knowledge Base: Shared Canvas

Agor was Max's answer to "how he uses AI beyond a research tool", but doing data modeling, writing data pipelines, even legal or HR roles he added later to Agor, so you can give company-wide roles to agents that can be fed with dedicated documents and context, and triggered by any employee internally. In contrast, others see the jobs and avoid asking the same questions, reusing the output for new queries—Andrej Karpathy's concept of an LLM-maintained shared team wiki—which builds an internal knowledge base.

Initially, when we first chatted, Agor had already changed how he worked as a CEO, but since then, Agor has gone even further. Agor can replace high-level tasks while still being very hands-on by working closely with the code via git worktrees (branch cards in Agor's UI) and verifying the code in the PRs it produces. Max also added OpenClaw-like features around memory and identity via dedicated Markdown files, such as AGENTS.md, SOUL.md, MEMORY.md, so that Agor's agents can learn from recent runs and carry a purpose and clear instructions. This led to role-based agents called Assistants (use agor-assistant as a template to build your own).

Example of different Agor assistants: Saul for legal, or OpEx for observability and so forth. | From the Webinar Anatomy of Our Internal Data Agent

Inspired by OpenClaw's agent loop, Assistants became first-class citizens, persistent AI companions with memory, identity, skills, and scheduled tasks integrated into Agor's canvas, multiplayer workflows, and reachable directly from Slack, for example. Additionally, Agor adds features beyond OpenClaw, such as better multi-user support, RBAC, one-click, full session inspection, and many more.

Asked about the goal of Agor, Max said:

The initial premise was to remove DevOps and set up time for other members of the company. Instead of people needing to connect all the MCPs or CLIs to add API keys, set permissions, or integrate with Slack, the prompt window with the needed context is there and ready to start.

Visual and Spatial Memory

When you do a lot of agent work, it's really hard to keep up with all of it. That's where Agor's visual and spatial overview really helps and is unique in its approach.

It brings the local and private session to a server, where everybody can see and work together on the same queries, and use the insights from other results, as dashboards are built for. So instead of keeping output locally, others can source the artifacts generated by agents, stored as Artifacts within Agor, ready to use by anyone, with no integration or deployment needed.

Example Artifacts such as AI Ops Command Center, Tool Log triage, these live directly in Agor based on an Agor session

Or how Agor tracks its own spending across sessions: See demo at Live Talk: Anatomy of Our Internal Data Agent at Preset (ft. Agor)

Or the data needs an analytics agent to support, such as self-serve, the data team, and extras such as memory, skills, documentation, etc.

Context Layer: Back to Semantic Layers?

Max also believes that we are going back to the Semantic layer, or using it for AI as agents benefit from structured information - helping with the data model and SQL part, to make sure it's correct, especially with the needs of AI agents and the persistent challenge of providing trustworthy self-service analytics.

With the shift of semantics outside of the BI tool, versioned, testable, portable, it's a chance for better integration between business domain experts and data engineers. His thinking has evolved since he wrote the article, and Max told me:

I see two different semantics: the semantic layer and the YAML. There are the hard constraints — not every area needs that strictness — and then the softer ones with Markdown and Agentic Skills, good for 80-90% but with no guarantees.

AGENTS.md For Databases: Markdown Stored Inside the Database Itself

Based on that idea, Max created an experiment to bring the AGENTS.md convention into the database. DB-AGENTS reserves a dedicated schema and table, _agents._agents, that holds agent-oriented documentation at different scopes (global, domain, schema, table, and even column). You write the docs locally as markdown files with YAML frontmatter, and a small CLI (dba) deterministically syncs them into that table — since databases don't let you drop files into them, the table becomes the file. Agents then query it at session start the same way they'd read an AGENTS.md, making it a natural companion to INFORMATION_SCHEMA: one holds structure, the other holds meaning. Max calls it a "soft semantic layer", which maps directly onto the hard-vs-soft split he described above. Check out the repo at db-agents.

With context being key for agents to understand what we humans know, Agor also added a context layer called knowledge. Agor Knowledge acts as a central place where humans and agents can store, organize, connect, and find the context that makes work compound over time, with Slack quickly becoming the main interface to many of the team's agents.

How Do We Sandbox Agents for Safe Workflows (Okta for Agents)

Another big topic is security when agents have so much access to powerful CLIs, sometimes root access to systems or databases containing private keys, or just downloading random skills from the internet that may contain hidden secret messages.

Max coined the idea of Okta for Agents, which I found super interesting, and something I believe will become ever more important if we want to find a healthy way of working with agents in enterprises or with sensitive data. Okta for Agents means working around identity, scoped delegated permissions, leases, and audit logs.

When asked how he's managing security, verifying what Agor or the agents are doing, Max responded:

I let the workers run in god mode3, but using dedicated environments/sandboxes, hooked to a dedicated git worktree repo, it can run autonomously and solve problems on an initial prompt, visualized in a shared canvas style.

I asked how he sees Okta for Agents being implemented. We desperately need it, he said, granting agents permissions like impersonation. Delegating the permission is an OAuth. With the roles, we can scope permissions strongly. E.g., the sales agent only has access to sales documents.

When asked at what level to integrate the Okta security layer, Max said it hasn't been solved yet. Still, he sees it as the same question: whether we have 50 agents or 50 users who use a platform, both need a security layer.

Likewise, Max shared:

I trust agents the same way as I would an employee.

The twist is that it adds a whole new dimension to RBAC. It's not just "the bot gets an email account" — it's "the bot gets an email account, but can only read mine, and via MCP rather than as a real user." Not so different from onboarding a human personal assistant, except this assistant can help with nearly everything, so the blast radius is much bigger.

Max's own example: he saw a 1Password skill and immediately backed off then reconsidered, wondering whether the bot should have its own 1Password account with only safe credentials shared into it. Which is exactly the problem: you can be strict on paper, but the moment the agent has your email, Slack, and calendar, it can leak private things all day. (Full discussion at this post)

Declarative and Non-deterministic Outcomes?

Related to security is the deterministic, repeatable behavior of data sets with the same input. Agents are the opposite: probabilistic. I was curious to hear from Max, who initially defined the functional data engineering paradigm for deterministic and idempotent batch data processing, what he thinks about the non-deterministic outcomes of agents, specifically with large language models.

Max said, regarding declarative definitions, that he finds a claude.md is usually sufficient for most tasks that have a git repo, more context, and an issue or PR to work with, given the initial prompts come from users who know what they are doing.

Regarding reliability, Max thinks about using good methodology references. Agents get it and understand it. E.g., data modeling practices such as Kimball are still valid, or the approach shared by him with Entity-Centric Data Modeling (ECM), he says, and when prompted to model in those patterns, agents follow them well (either via research or provided).

The other part is that some non-dangerous work can have vibe data pipelines, and there's no danger. And there are cognitive-depth tasks, such as a complex Spark cluster, where you can't just debug quickly with large data sets.

Also, the field varies: not every area is getting agentic-piled as fast. E.g., platform demands go through the roof (see GitHub outages), so we have 10-20x the platform needs, but at the same time, the work is critical to be correct. So it depends.

Future of Agentic Workload, and Canvas Development in Teams

When asked about how Agor has changed how they at Preset develop products (if at all?), or made them more effective, Max said:

There are more agents than humans nowadays. Everyone has a Claude Max plan, and agents handle almost all code writing.

And on a personal level:

I haven't written a function by hand for a long time, and I might not anymore — except when I feel nostalgic.

He also thinks that the Yap-to-Ship Ratio, a metric that he announced half-jokingly on LinkedIn, describing people's velocity by just getting stuff done without involving others at every step, will be very low-yap for 10x engineers, as they solve the problem and ship a solution without much back and forth.

They deploy it somewhere for others to use, not only for human consumption, but as a solution or CLI that other agents can use to discover further and solve their problems. A high Yap-to-Ship ratio would mean lots of human interaction, which is the clear new bottleneck.

As human code review gets bottlenecked, I asked how he does the review. He said he uses Codex with sub-agents to review, ensuring everything is DRY (Don't Repeat Yourself) and that all expected callbacks are made.

You can also ask the operator assistant agents if you are not sure whether an implementation is correct.

Amdahl's Law: Can't Go Faster if not End-to-end

One bottleneck is still Amdahl's Law. We can speed up tooling by using extremely fast agents, but unless the end-to-end workload is sped up, we only increase by a 2-3x factor, not 10 or 100 as any one tool does. This also overlaps with Max's Yap-to-Ship ratio: if PRs need the human in the loop to review many of them, the overall speed at which we build is not faster.

Another side effect is that it takes a lot of context switching. Max said he has ten active sessions in Agor. He is good at context switching (maybe also learned through recent Agor workflow? ).

Predictions for 2026

It's hard to predict the future with AI, but Max took a stab and shared his predictions for 2026 and categorized them into wired and tired: Find the full talk at Webinar.

Max's AI Setup for Data Engineering Work and Managing His Company

We end this interview with Max's setup for working with agents, since we didn't have time to go into full details on the call. I'm sharing the one he shared four months ago. I'm sure it changes almost daily. Still, it helps us get a good overview of his software engineering stack for the team at Preset, as well as his personal local computer stack.

For software engineering and data engineering:

• Preset team instance of Agor behind VPN with a dozen boards, boards are mostly repo-oriented. Full Unix impersonation, backed by PostgreSQL.
• doing most of my work on board with the agor-openclaw framework, agent is pushing projects across a kanban-type layout: tons of new automation there. Agent checks on agents, prompts them, moves worktrees to "needs human review" zone if/when needed
• coding workflow is Opus 4.6 as a planner, Sonnet 4.5 / Opus 4.6 for most coding, Codex 5.3 as the reviewer (god it's so good)
• data engineering stuff: dbt/airflow repo + Superset MCP, superset-sup
• "Command center" is agor-openclaw on Opus 4.6, monitors other agents, intricate HEARTBEAT.md with pseudocode to make a decision for coding project (worktree) on that board

And his new "Personal assistant" local instance of Agor (brand new/sensitive):

• Beefy Mac Studio at home
• connected to "productivity" tools (google-workspace-mcp)
• connected to Slack through a semi-homegrown skill --- read-only for now, mostly to summarize activity
• connected to Notion MCP
• connected to "contracts" repo, where I sync with Google Drive for all Preset contracts
• connecting to Hubspot soon
• goal is to automate most of the automatable CEO-stuff as discussed above

Coming up

We've learned how to use Figma for agents with Agor and to collaboratively work as a team, using shared prompts and creating artifacts. We've seen how Okta for Agents is needed but really hard to implement, and how the future of AI is mostly about context and how to integrate it well. Plus, we learned how Max automates many tasks as a CEO with dedicated AI assistants and still produces low-level code with the same assistants for both his personal and company-wide needs.

I hope you enjoyed this fourth interview with Max. Huge thanks to Max for taking the time to speak with me (twice!) and for sharing his experience with all of us. Follow him on LinkedIn, GitHub, or on Preset Blog, where he shares his distilled thoughts on the ecosystem, and obviously, if you want to know more about Agor, check it out at Agor GitHub repo.

Max shares a lot of his ideas and thoughts online. Here are some further articles and interviews to read/watch:

• AI Enablement Engineer: The Highest-Leverage Role in Tech
• Check the Joe Reis interview where Max shares more on the discussion From Airflow to AI Agents: On Building Agor and Running a Company with AI Agents

More interviews are coming out, so please share feedback, questions you might want to ask, or your experience working with AI in the data space. We're all in this together, figuring it all out.

when we first discussed in February 2026 claudette-cli, a CLI for managing git worktrees, originally built for Apache Superset development. god mode means scoped/sandboxed/audited environments, not uncontrolled access

On the DABStep agentic analytics benchmark, Guides reduced agent query errors by ~99% (from 302 to 1) across an array of complex business questions, and lower costs by ~55% when compared with agents discovering context on their own.

Guides are available now for all MotherDuck users; see the docs to get started or read on to learn more.

Analytics agents are still eager interns

Anyone who has used an agent to explore data knows that the agent is trying its best; it'll exhaustively look up schemas, infer join relationships itself, and tirelessly push for an answer that sounds decisive, appears well-presented, and is often totally, dangerously wrong. AI models struggle with the tradeoff between "achieving" a goal, even if wrong, and getting you the right answer more thoughtfully. It gets worse the more complex a data warehouse becomes.

We've certainly felt this analyzing our own business in MotherDuck, and our customers feel it in theirs. They're trying just about everything they can to steer agents in the right direction, from team-level skills, custom MCP servers, overloading DuckDB's COMMENT ON functionality, you name it. Everyone hates this state of affairs.

Regardless of the inquiry or task, the path to decision-making cuts through querying a data warehouse, so why not put the context there too, queryable in SQL?

Crossing the context chasm

Enter Guides: markdown files with a title and description, much like an agent skill. We believe that the warehouse, not a BI tool or point solution, is the rightful home for every piece of context about a business, both structured and unstructured. Guides live in your warehouse, versioned and queryable like any other object.

1. Accurate search and retrieval. Guides can programmatically reference your catalog, Dives, Flights, and even other Guides, so any lookup queries can automatically find the right Guide. Topics further improve agent search over tens or hundreds of Guides.
2. Automatic distribution. Guide ownership comes in two layers: organizational and user-level. Org-level updates are automatically propagated, ensuring metric definitions stay consistent. User-scoped Guides allow individuals to cultivate private versions for exploration, style consistency, or other personal preferences.
3. SQL-based management. Guides can be called and managed entirely with SQL through any MotherDuck client, which simplifies version control and CI.

So what goes in a Guide? Virtually everything an agent needs to know to be trusted with your data: metric definitions and join relations, the gotchas and caveats that currently live in your team's heads or in a Slack thread, and style guidance for Dives, our agent-native visualization tool, and conventions for Flights, our hosted Python runtime for building data pipelines.

For example, this Guide contains context about how to calculate fees, given a set of duplicated transactions in a table:

---
id: fees-formula
domain: fees
summary: The fee formula and the dedupe-by-fee-id rule when averaging fees.
---
**Fee formula (per matching rule, per transaction):**
```
fee = fixed_amount + (rate / 10000.0) * eur_amount
```
`rate` is in basis points, so divide by 10000. `fixed_amount` and `eur_amount`
are euros.

- **Totals** (e.g. "total fees a merchant paid"): sum `fee_amount` over every
  matching (transaction × rule) pair. A transaction matching 3 rules contributes
  3 fees.
- **Averaging across fee rules** (e.g. "average fee the card scheme would charge
  for a transaction of V eur"): a single fee `ID` always has the same
  `fixed_amount` and `rate`, so **deduplicate by fee `ID` first**, then average
  over the distinct rules. Don't average over duplicated rows.
- For abstract "for a transaction value of V eur" questions there is no real
  transaction, so substitute the literal V into the formula:
  `fixed_amount + rate / 10000.0 * V`.

See `sql-avg-fee` and `sql-total-fees-merchant` for worked templates.

Guides follow your data, not your agent harness. If you switch between Claude, Codex, or any other harness, Guides just need access to the MotherDuck MCP server for an agent to start using them.

Benchmarking improvements

We put Guides to the test on DABStep, a public benchmark of multi-step data-analysis questions. Giving an agent Guides as context reduced agent query errors by ~99% (from 302 to 1) and cut the cost per run by 55%.

With Guides, a small, fast model (Gemini 3 Flash) answered 418 of 419 held-out questions correctly~99.8%, at about two cents per question. The setup is simple: a compact skill that teaches the agent where knowledge lives, plus a context layer of Guides it loads only as each question needs them.

Aside from the obvious improvements on accuracy, the cost delta is striking. At 55% lower cost per run, the same budget buys roughly twice the tokens: longer tasks, more feedback turns. Adding context with Guides delivers improvements far greater than simply plugging in the latest frontier model, not to mention the latency budget preserved in using a smaller, faster model.

You can learn more about the benchmark and reproduce it here.

Getting started with Guides

Like our other agent-native tools (Flights, Dives), Guides are designed with the MotherDuck MCP Server as the first-class interface for creation, updates, and management. You can use MCP clients like Claude, Codex, and Cursor to interact with Guides; the MCP Server will use them by default.

The fastest way to improve agent performance with Guides is to bootstrap: distilling context from your business into an essential set of Guides. This resource provides a framework for shaping an initial corpus of context into useful Guides. Simply connect your MCP-enabled agent and point it at the docs page to get started.

You can also manage Guides through the built-in SQL functions (e.g. MD_CREATE_GUIDE()). This enables source control with git, as we've documented in this example. Govern context in a GitHub repository, then use the SQL functions in CI to execute changes.

Happy guiding!