Consulting firm McKinsey & Company is going to ask some entry-level candidates to have a 10-minute conversation with an AI simulation of a client as part of the interview process, according to The Wall Street Journal.

The AI simulation "aims to reflect 80% of the scenarios McKinsey consultants might encounter in their day-to-day work," the WSJ says, and it isn't designed to "mimic an unhinged client." The AI won't score the candidates - humans will be in the room to assess the candidates and see how well they deal with the simulated situations.

The McKinsey tool will be in testing for undergrads seeking business-analyst jobs in "some" offi …

Read the full story at The Verge.

I'm just going to come right out and say it. I love the approach Apple has taken with the HomeView. I think it's the shared, always-available household interface that my family might finally use. Is Apple's first smart display my dream smart home dashboard? No. But is it the right product for Apple Home at this moment? Absolutely.

A lot of initial reactions to the $299 HomeView (which looks like a giant Apple Watch on a flatter metallic HomePod Mini) ask why you would want it when you can do most of what it offers on your iPhone or iPad. And yes, its features replicate many of the things you already do on the devices you use all the time. B …

Read the full story at The Verge.

OpenAI is facing a new wave of lawsuits from eight US states that accuse the company of harming children and misleading customers about the safety of ChatGPT, as reported earlier by Reuters. The lawsuits, filed separately by Iowa, Kansas, Nebraska, West Virginia, Arkansas, Arizona, Idaho, and Montana, allege OpenAI unlawfully put profits over safety when developing ChatGPT.

The string of complaints claims that OpenAI violated local consumer protection laws by failing to warn customers about the dangers of ChatGPT, citing several lawsuits filed by the family members of teens and adults that allege the AI chatbot played a role in their loved …

Read the full story at The Verge.

We've all gotten a scam text about a nonexistent parking ticket or a fake package delivery, but hopefully you'll start seeing fewer of them. Microsoft says it helped dismantle a marketplace for scammers sending phishing messages like those around the world. Through an investigation with Japan's National Police Agency, it tracked scam activity back to a marketplace called YAM Store and a pair of phishing kits, CoGUI and Iron Man:

Since January 2026, YAM Store, CoGUI and Iron Man have collectively enabled more than one billion malicious messages targeting over 75,000 organizations worldwide, including more than 750 million messages geared to …

Read the full story at The Verge.

Last week, Anthropic and OpenAI looked like they had the AI race to themselves, pulling ahead with increasingly powerful models that left their rivals in the dust. Google seemed hopelessly far behind, while Meta, despite spending billions to revive its floundering AI ambitions, had yet to establish itself as a serious contender. Even the latest models coming out of China, impressive as they were, appeared to be playing catch-up.

Then, in the space of a few days, everything changed. Google and Meta both unveiled frontier models they claim can go toe to toe with the best from OpenAI and Anthropic. Suddenly, the race is back on - and it's anyo …

Read the full story at The Verge.

New York Attorney General Letitia James revealed a years-long multi-state investigation against Character.AI as they now seek to require protections on consumer data sold through its bankruptcy proceeding.

James is among 40 bipartisan AGs who filed a notice of interest in Character.AI's bankruptcy case "to put all parties on notice of the regulatory issues that will need to be addressed in any sale or transfer of the Debtor's business or assets." Character.AI announced Tuesday it was filing for Chapter 11 and selling some assets to Disney. But the AGs warn there could be serious risk involved in the transfer of the technology due to the "hi …

Read the full story at The Verge.

While I’m thinking about food fraud (see last week’s post), I’ve always said that the fish counter is the wild west of the supermarket.  The Food and Agriculture Organization of the UN would agree.

This FAO report:

 provides information on tools that can be used to fight food fraud for aquatic products, and international case studies illustrate the scope and impact of fraud. The report reviews regulatory frameworks as well as standards such as those set by Codex Alimentarius, FAO guidelines, and GFSI‑benchmarked schemes, advocating for harmonized labelling, mandatory scientific names, and improved traceability. It emphasizes the role of consumer awareness and industry transparency in combating fraud.

Well, good luck with that.

The report covers these kinds of fraud:

There is lots of it:

What can I say?  Know your fish seller.

Caveat emptor!

The post A fishy story: Food fraud in the fisheries and aquaculture sector appeared first on Food Politics by Marion Nestle

Em 1986, por acaso, com o objetivo de criar um single para o novo álbum de George Harrison, surgiu o mais bem sucedido dos supergrupos, o Traveling Wylburys. Sob este nome, George Harrison, Bob Dylan, Roy Orbinson, Tom Paty e Jeff Lynne, gravaram dois discos primorosos (o segundo sem Orbinson, que faleceu de um infarto antes). A banda não fez turnê.

O fenômeno repetiu-se aqui no Brasil com Os Tribalistas, em 2001. Arnaldo Antunes, Marisa Monte e Carlinhos Brown formaram um trio descaradamente pop, sem pretensões, puro entretenimento, Obteviveram sucesso comercial comparável ao dos Secos &. Molhados quase 30.anos antes. O mais vendido e tocado do ano, nas rádios, lojas e carrinhos de pirataria.

Com o álbum Vice-Versa, Arnaldo Antunes e Adriana Calcanhotto não devem repetir o o sucesso dos dois grupos citados. Isto  porque a maneira de se escutar música mudou muito desde o advento das plataformas de streaming. Nem tem mais carrocinhas de pirataria pra, involuntariamente, divulgar o disco

. 

O álbum tem em comum com Os Tribalistas o fato de ser uma coleção de canções assobiáveis, engenhosas, criadas por dois artistas também bons de letas. Além disso, os outros dois Tribalistas, Carlinhos Brown e Marisa Monte, participam como compositores em uma faixa cada, enquanto Marisa também toca. Na faixa em que é parceira (Na Minha Carne Viva). A despretensão dá o tom. E o melhor exemplo é As Bancas de Jornais, um inventário lúdico do que  as bancas passaram a vender em lugar de revistas e jornais.

 A produção de Pupilo enfatiza a simplicidade, Como um solo básico de sintetizador cerzindo a melodia de Também Capaz (tocado por Vitor Araújo, que desempenha importante papel no disco). Ele forma a banda base com Lucas Martins (baixo), Pedro Sá (guitarra), e Pupilo (bateria e percussão). E ainda, Sthe Araújo e Luiza Lian, vocais de apoio, mais a guitarra de Tomé Araújo, em quatro faixas.

Samba, rock, maracatu são alguns dos ritmos do disco, com várias faixas em outros tempos fadadas a hits radiofônicos. Uma dessas é Contemplando a Folia (em parceria com Pupilo) um dos melhores Maracatus canção que escutei em anos. Contraste com a guitarra surf em Sorriso Livro, dessas pérolas pop que Carlinhos vez por outra saca da cartola (parceria com Denny e Edmundo Cardoso). 

Ao contrário do Traveling Wylbury, e Tribalistas a dupla Adriana e Arnaldo vai pra estrada com turnê de Vice-versa.

A reader and doctoral student in my NYU department, Earlene Cruz, sent this classic example, a press release from the University of Leeds: Major trial examines no-sugar sweetened soft drinks

The major new study was published in the British Journal of Nutrition and provides long-term clinical evidence that NNS beverages – specifically those containing aspartame, acesulfame potassium (acesulfame K), and sucralose – are equivalent to water in supporting weight loss and long-term weight maintenance.

The press release explains the rationale for doing this: “Overall, the results do not support concerns that NNS beverages disrupt appetite regulation or have long term metabolic harm.”

Who would be most interested in debunking this idea?

High marks to the press release for disclosing the funder: The American Beverage Association.

And why would the American Beverage Association care so much?

Policy impact: Importantly, the findings directly address recent World Health Organization (WHO) guidance, which advised against using non-sugar sweeteners for weight control due to uncertainty in observational studies. The SWITCH trial provides long-duration, randomised controlled evidence which can be used to inform global guidelines.

Isn’t it handy that the results can be used to argue against the WHO’s advisory.

This is one reason why beverage companies and their trade associations invest in research.

I took a look at the study itself and was glad I did.  Check this (my emphasis in red):

The post Industry-funded study of the week: the American Beverage Association at work appeared first on Food Politics by Marion Nestle

Most semantic layers come with a great declarative modeling language to define metrics and measures well¹, but very soon after, you start building wrappers around the semantic layer that enable agentic work and context engineering, that work well with harnesses and interfaces, and that allow flexible queries at runtime, without the need to rebuild or recalculate the measures in YAML.

The other problem is that most data warehouse or analytics solutions basically lock you in with their proprietary semantic layer. The Open Semantic Interchange (OSI, new Apache Ossie) standard, making it possible to convert definitions from Snowflake to the dbt semantic layer, will reduce this, but all the glue code you build on top is still tightly integrated into that very semantic layer, or you might get some of the capabilities mentioned above from that proprietary software. So you might be using an open data format, or an OSS business intelligence tool to integrate measures into your semantic layer, but if that semantic layer is not open, you might still be locked in.

That’s why SLayer tries another approach and ships its open source Semantic Layer with a query engine, agent tooling, and context primitives out of the box, having all the wrappers that you’d most certainly build anyway directly with it. And everything is under the MIT license.

Why Yet Another Semantic Layer?

If you follow the space, there are many semantic layer tools, starting as early as 1991 with SAP Business Objects, and more “Modern Semantic Layer” tools such as Cube or the dbt semantic layer, etc., which are mostly YAML and outside of the BI tools.

But why might we need yet another Semantic Layer tool today? Especially when there are new terms like Context Layer and Knowledge Graph floating around (I wrote a primer about it). This is a fair question.

The biggest reason is mostly this: if you start with any of the modern layers, once you have defined your metrics in YAML and have a good workflow of versioning them in git, you can change fast and re-deploy, roll back, and even agents can easily contribute, with changes mergeable and transparently seen in the git log with PRs if you want. But what you always end up with is writing glue code around your Semantic Layer.

For example, in 2018, when we built our own Semantic Layer at a previous job, a Metadata store held all our metrics in a simple SQLite database for our SmartAnalytics application, which then had all the complex queries pre-defined for users to use, querying in milliseconds against Druid as our OLAP engine.

But we ended up building an API to fetch/create new metrics. We had to build a lot of glue code so that the integration with Druid worked well, that the application could fetch the metrics in a way that worked with its C# application logic, that we could use it in our Dagster data pipelines, that data scientists could use the same metrics in Jupyter Notebooks, or in the web app where we showed millions of points that had to be plotted on a map when zooming around the map. The declaration was already a major win, as we could centralize the business logic in one place for everyone to use, but we had to add the APIs and glue code ourselves.

Today, with agents, there’s one more layer that you need to build: the implementation for working with agents and for collaboration between humans and agents. So there you implement another wrapper layer. Usually, the paid solutions might solve some of these problems, but shouldn’t that be included out of the box with open source? SLayer, another semantic layer, and the company Motley think yes.

Also missing is an included query engine, though. MetricFlow and Malloy have an engine to generate and query, but the semantics are more constrained. SLayer, for example, comes with an engine out of the box that supports powerful expressions like sum(revenue), avg(revenue), sum(revenue) / count(*), time_shift(sum(revenue), -1, 'year'), or multi-stage queries such as:

Orders grouped by customer activity bucket. First calculate order count per customer, bucket that, then use the bucketed result as a dimension to group orders by.

This is a multi-stage query, a combo of two queries, and something that can be common in an enterprise, so it helps if we can define this with a simple expression language, as it’s very difficult to express in SQL.

[!info] Why not just dump the text into the agent?

Another question you might have: why not just dump the text directly into the chatbox of an agent? The reason is that it usually works on a simple demo project or a small one, but does not scale to the enterprise. One showcase of larger context needs is LiveSQLBench-Large. Another angle is the reiteration of agents, re-deriving cardinality, join paths, and metric definitions on every session instead of reading them once, as well as two people asking the same questions and getting different answers; an integrated Semantic Layer avoids drift in the metrics returned.

Three Out-of-the-Box Capability Layers That Come with an Open Agentic-First Semantic Layer

If we look at what the capabilities and requirements for a new agentic-first and fully open source semantic layer are, they are managing context and enabling queries easily based on it, flexibly and with an expressiveness that makes it unambiguously clear to humans, but also to the agents.

This needs tooling that has a more powerful expression language and a query engine that supports it, integrated deeply into the definitions but also into the query engine. Yann Ranchere, co-founder and CEO of SLayer, says it this way:

A strong agent-first semantic layer, with an expressive query engine, agent tooling, and context primitives, is a hard problem and a key component of future agentic and analytics solutions and that it is better served by an open-source project so that developers can spend more resources and effort on context, agent harness, visualisations and interfaces.

To tackle all of these, we can compress them into three pillars: context primitives, an expressive and flexible query engine, and being agent agnostic, with all of these capabilities integrated into OSS tooling that isn’t gated behind a paywall².

1. Context Primitives Out of the Box: No More Wrappers and Glue Code

Pre-agentic Semantic Layers were built for dashboards that replay the same queries each time, so joins, aggregations, and time logic get defined once in YAML at design time. This is great for large and complex business logic, like revenue.

But the definition alone was never enough. Think back to the Metadata store example from above: the metrics lived in one place, but everything around them was glue code we wrote ourselves: the API to fetch and create metrics, the Druid integration, the access from C#, Dagster, and Jupyter. Every consumer needed its own way to find out what metrics exist, look up how they are defined, and query them.

With agents, the same three needs come back, only stronger. An agent doesn’t know your business. It has to find the right measure among hundreds, inspect how it is defined and joined, and ideally learn from what worked the last time someone asked a similar question. This is what I call context primitives: the small, composable units a semantic layer exposes so an agent can retrieve exactly the business knowledge it needs for one question, without loading the whole model into its context. In SLayer, these are:

• Models: measures, dimensions, joins with their cardinality, and grains, defined in YAML and versioned in git, or imported from dbt, Cube, or OSI.
• Search: one search tool over entities (datasources, models, columns, named measures) and memories, so an agent finds orders.amount from a natural-language question instead of reading every model file.
• Inspect: the rendered definition of exactly one entity, with descriptions and sample values, for when the agent already knows what it wants.
• Memories: notes an agent writes about a part of the schema, optionally with an example query, tagged to the entities they belong to (“Card TPV excludes refunds after day 45”). The next agent finds them via search before it queries.

Together they form the search → inspect → query flow we’ll see later, and they ship as MCP tools, a REST API, a Python client, and a CLI. These are exactly the wrappers we would otherwise build again, around every semantic layer and for every harness.

In the end, we want to build fewer wrappers ourselves and less custom code, and have all semantic capabilities provided end-to-end as open source so developers can spend more resources and effort on context, agent harness, visualisations and interfaces. The same holds for the second capability: a flexible query language and engine belong to the semantic layer.

[!info] A semantic layer should be a governed query engine, not a SQL wrapper

Below you see an example of the same business question, and two ways to answer it. One is SQL the agent has to get exactly right. The other is a structured request with governed joins, query-time formulas, and generated SQL underneath - producing the same governed answer every run:

2. Expressiveness + Flexible Query Engine That Works with AI Agents, Agnostically

Better expressiveness and more integration also mean more efficiency with agents, instead of going through many wrappers and non-integrated, non-battle-tested code with much longer round trips, meaning that agents otherwise use lots of tokens, with more ambiguity and less speed.

This is essentially the origin story of SLayer: building a reporting automation on Cube, whose wrapper grew into a complete rewrite. But in order for agents to express their query intent in a way that’s as concise as possible, and just formal enough to be unambiguous, we need an expressive query language integrated with its query engine. The query engine of an integrated Semantic Layer needs to deterministically figure out the necessary joins, subqueries, and safeguards, both for correctness and to have the right context understanding, to avoid needing to query the full world or all of its huge context, saving context³.

This is also where the static, design-time model hits its limits. If an agent asks a question that wasn’t planned, the pre-defined pattern breaks. Or the workaround, a model that pre-declares every measure × aggregation × time-shift combination, explodes. But there are more complex things for which we need additional logic written, for example, doing an aggregation across different grains, connecting the missing dimension, and then aggregating based on the result set, all in a single concise expression. SLayer calls this re-aggregation: a multi-stage aggregation inline in one query, no second stage needed, and guaranteed fan-out safe (the multi-stage query introduced above does the same across two stages): avg(sum(orders.total, partition_by=[city, region])) grouped by region, the unweighted average of city totals per region.

Another feature some OLAP engines like Druid or ClickHouse bring is moving decisions to query time, so you can define metrics while querying your data (not at processing or development time). But you need the engine for it and now write custom integrations and APIs for each query engine again, whether you use Snowflake, Cube, or any other engine.

Handling different grains, cardinality when joining, and many-to-many relationships are hard problems, and every bit of integration in that direction helps the domain experts querying and defining complex metrics in large organizations, once. A Semantic Layer is much more than a database schema.

An agent needs to express its query intent concisely and unambiguously. The joins, subqueries, and safeguards are the engine’s job, and they have to be deterministic. SLayer’s SQL principles show that by using an AST (Abstract Syntax Tree) end to end and SQLGlot transpilation. Check out Try SLayer for an example.

For the agent, this means it states the what, such as which measures, at which grain, etc. The engine deterministically owns the how, like any query planner on a database, but on top of our defined metrics, with the intent to produce the same SQL every time. This leads to more trust in the agent’s answer.

[!note] A Quick Evolution of the Semantic Layer
A quick recap of the history and evolution of semantic layers. Originally, and still, the key purpose of a semantic layer is to have a virtual layer between the raw data and the dashboard or end-user analytics, without needing to manage direct access and permissions to your raw data.

This short recap shows the evolution and where that comes from (originally shared here, but extended with the latest):

• 1991: SAP BusinessObjects Universe and BI semantic layer
• 1997: SSAS and MDX, with their logical modeling layer with MDX, define business metrics and dimensions in a structured way
• 2013: Kimball discussed the concept of a semantic layer in #158 Making Sense of the Semantic Layer
• 2016: Maturing BI tools with an integrated semantic layer, such as Tableau, TARGIT, PowerBI, Apache Superset, etc., have their own metrics layer definition
• 2019: Looker and LookML were popularized as the first semantic layer
• 2022: Declarative Semantics and metrics with tools such as Cube, MetriQL, MetricFlow, Minerva, and dbt arose with the explosion of data tools around 2022
• 2023/24: The evolution of data querying and natural language queries with the integration of LLMs and catalogs. Text-to-SQL, embeddings & Retrieval-Augmented Generation (RAG)
• 2025: Resurrection of Knowledge Graphs & Ontologies
• 2026: Agent-written Context Layer & Karpathy self-curating LLM

Evolution from Semantic Layer. See also related Enterprise & Personal Knowledge Management Evolution, and you can find another opinion in The Shape and Feel of the Post-AI Data Stack.

3. Use Your Harness of Choice: Agentic-Tooling Native, with Unambiguous Semantics

Other challenges are quickly changing queries while we explore the data with agents, as well as that we might need to use Copilot on Microsoft because it’s integrated, or we like the way Claude works. So the semantic layer must integrate into these tools, not the other way around, where each semantic layer builds its own AI harness.

Similarly important is to define metrics unambiguously, so that the time dimension, for example, one of the hardest dimensions to define⁴, is clear and flexible: time_shift(sum(order_total), -1, 'year'). Imagine pre-defining these in YAML at pre-build time, for all dimension/granularity combinations. Instead, we make it flexible at query time, at runtime, for agents to simply adapt to their needs.

The goal: Combine different grains - be very flexible, not depending on technical limitations such as grain or cardinality, but based on business demands. The query engine and its semantics should handle the rest, and agents can help us with it. Letting the agent ask what it needs, instead of what the semantic layer can express in its limited way. We know the limitations from DSLs (Domain Specific Languages): they are good for non-technical people to not break anything or to just stay within the prepared queries, but not so much if you need new queries or have fast-changing requirements. So we don’t need a DSL; we need flexibility and more expressiveness.

Being able to use any harness, being agnostic, is also what keeps the tool out of vendor lock-in, as it works within your existing environment.

Egor Kraev, co-founder of SLayer, says:

An agent should be able to express its query intent in a way that’s as concise as possible, and just formal enough to be unambiguous, but let the deterministic machinery figure out the necessary joins, subqueries, and safeguards, for both safety/correctness and context-saving reasons.

[!info] What is a “(AI-) harness”?
The term popped up on social media, and it means scaffolding around model (tool loop, prompts, context management), working autonomously, not needing to constantly ask us, but that can run for 20 minutes and solve a hard problem. Harnesses are Pi Coding Agent, OpenCode, Aider, Goose, Cursor, Amp, Claude Code, and Codex, which have now built in this functionality.

What an Embeddable, Agentic-First Semantic Layer Looks Like

So with all of this in mind, what would yet another Semantic Layer look like with the three foundations of avoiding building wrappers, including an expressive query language and query engine, and being able to use our harness of choice?

Luckily, we can look at SLayer, an open source implementation of these principles. SLayer is focused on the common agentic search → inspect → query flow with a search tool for efficient discovery and a memory store for linking the relevant business context. Try it on GitHub, and start with the quick start:

1
2

git clone git@github.com:MotleyAI/slayer.git
uv tool install 'motley-slayer[all]'

And use the demo data of Jaffle Shop, preloaded with zero config needed, with your agent of choice, here Claude, but you can use any MCP integration, included in the OSS version. Try it and get a feel for it:

1

claude mcp add slayer_demo -- slayer mcp --demo

Or even better, with your own data - a Postgres DB in this case:

1

slayer datasources create 'postgresql://user:${DB_PASSWORD}@hostname/db_name'

All of the integration is better served open-source, and it is with SLayer.

What’s Next?

The usual flow of building a semantic layer is that you start with a cloud warehouse, you start up something quick and fast, the dashboard or insight gets more useful, more people use it, more want new metrics added, so you patch and update the ETL pipeline. The pipeline gets slow, so people ask to improve it, so you build caching mechanisms and materialized tables to speed it up, but all of a sudden, you end up with a mess. All your metrics and business transformations are scattered around in the ETL pipelines, in the materialized views, in the newly patched scripts you build, and in ad-hoc dashboards.

So instead, we could use an agentic semantic layer that is prepared for fast-changing metrics and business requirements with its extendable query engine, integrated with any popular AI harness, as well as absorbing and defining the right amount of business context through context primitives.

In this article, we learned why we might need yet another semantic layer that is open source and built for today’s needs. If you decide on a semantic layer, look at agent-friendliness, query-time expressiveness, and entity and context discoverability. If it’s not included, you usually end up building it yourself. You want a semantic layer so agents don’t end up writing raw SQL.

Again, agents should be able to express their query intent in a way that’s as concise as possible, and just formal enough to be unambiguous, but let the deterministic machinery figure out the necessary joins, subqueries, and safeguards, for both safety/correctness and context-saving reasons. This increases query expressiveness and simplicity, so dimensions can be derived from aggregations, as well as multi-stage aggregations, or guaranteed fan-out.

Curious to learn more? See related blog articles and architecture decisions:

• Check out the amazing explanation on concepts like Models, Queries, etc. at Docs.Motley.ai.
• Architecture decisions SLayer made.
• Some comparisons such as dbt semantic Layer (MetricFlow) vs. SLayer, or Why our SLayer vs Cube agent benchmark couldn’t finish
• Why a Semantic Layer Is More Than a Database Schema

Full article published at Motley.ai - written as part of my services