Paul Iusztin

🤖 Senior Machine Learning Engineer • MLOps • Contractor ~ Helping startups engineer production-ready ML/AI systems.

I'm the author of the bestseller LLM Engineer's Handbook, lead instructor of the Agentic AI Engineering course, founding AI Engineer of a San Francisco start-up, and obsessed with making knowledge accessible through AI.

With over 10 years of experience in AI and software and 20 apps shipped, I teach AI Engineering as I wanted to at the beginning of my career. End-to-end. From idea to production. From data collection to deploying, monitoring and evaluation. With a focus on AI principles, software patterns and infrastructure systems that will thrive in a future dominated by AI coding tools.

My ultimate goal is to help other engineers escape PoC purgatory and 10x their AI Engineering skills.

.

If you want to become an AI Engineer pro, join Decoding AI for exclusive content on designing, building, and shipping AI software that works: 

🗞️ https://www.decodingai.com

See more:

🌐 Homepage: https://www.pauliusztin.ai
📚 LLM Engineer's Handbook: https://www.amazon.com/LLM-Engineers-Handbook-engineering-production/dp/1836200072/
🤖 Agentic AI Engineering Course: https://academy.towardsai.net/courses/agent-engineering?ref=b3ab31

.

✉️ For collabs, contact me at: p.b.iusztin@gmail.com

Senior Machine Learning Engineer

🟡 Scalable ML batch infrastructure for continuous training & inference

The client, a generative AI leader, struggled with manual training and calling their ML models. As a tedious and unscalable process, they needed to automate their ML processes completely and integrate them with their current web platform.

➞ 𝐃𝐞𝐬𝐢𝐠𝐧𝐞𝐝 and 𝐢𝐦𝐩𝐥𝐞𝐦𝐞𝐧𝐭𝐞𝐝 a modular 𝐏𝐲𝐭𝐡𝐨𝐧 𝐩𝐚𝐜𝐤𝐚𝐠𝐞 that composes the ML model required steps into 3 main batch pipelines that can easily be automated: feature, training, and inference, 𝐞𝐥𝐢𝐦𝐢𝐧𝐚𝐭𝐢𝐧𝐠 a 𝐭𝐞𝐝𝐢𝐨𝐮𝐬 𝟐-𝐡𝐨𝐮𝐫 𝐦𝐚𝐧𝐮𝐚𝐥 𝐩𝐫𝐨𝐜𝐞𝐬𝐬/𝐯𝐢𝐝𝐞𝐨.
➞ 𝐃𝐞𝐩𝐥𝐨𝐲𝐞𝐝 a scalable & cost-effective 𝐛𝐚𝐭𝐜𝐡 𝐚𝐫𝐜𝐡𝐢𝐭𝐞𝐜𝐭𝐮𝐫𝐞 and 𝐂𝐈/𝐂𝐃 𝐩𝐢𝐩𝐞𝐥𝐢𝐧𝐞 on top of AWS ECS & SQS that scales in and out based on the number of jobs, 𝐬𝐚𝐯𝐢𝐧𝐠 𝐭𝐡𝐨𝐮𝐬𝐚𝐧𝐝𝐬 𝐨𝐟 𝐝𝐨𝐥𝐥𝐚𝐫𝐬/𝐦𝐨𝐧𝐭𝐡.
➞ 𝐒𝐚𝐯𝐞𝐝 𝐦𝐨𝐧𝐭𝐡𝐬 𝐨𝐟 𝐟𝐮𝐭𝐮𝐫𝐞 𝐝𝐞𝐯𝐞𝐥𝐨𝐩𝐦𝐞𝐧𝐭 by using good software practices to make the Python module & batch cloud infrastructure flexible and composable.
➞ 𝐁𝐮𝐢𝐥𝐭 a 𝐯𝐨𝐢𝐜𝐞 𝐬𝐲𝐧𝐭𝐡𝐞𝐬𝐢𝐬 𝐏𝐨𝐂 in ~1 week required to 𝐜𝐥𝐨𝐬𝐞 the 𝐝𝐞𝐚𝐥 with one of the 𝐜𝐮𝐫𝐫𝐞𝐧𝐭 𝐜𝐥𝐢𝐞𝐧𝐭𝐬.

⚫️ Big data ingestion & archiving pipeline

The client wanted to expand its platform features by securely and safely ingesting, preprocessing, and storing TB of data into their platform.

➞ 𝐂𝐨𝐧𝐭𝐫𝐢𝐛𝐮𝐭𝐞𝐝 to the 𝐝𝐞𝐬𝐢𝐠𝐧 and 𝐢𝐦𝐩𝐥𝐞𝐦𝐞𝐧𝐭𝐚𝐭𝐢𝐨𝐧 of a 𝐝𝐚𝐭𝐚 𝐢𝐧𝐠𝐞𝐬𝐭𝐢𝐨𝐧 𝐩𝐢𝐩𝐞𝐥𝐢𝐧𝐞 that supports 𝐢𝐧𝐠𝐞𝐬𝐭𝐢𝐧𝐠 >𝟓 𝐓𝐁 of data in 𝐨𝐧𝐞 𝐠𝐨 in a reliable, fast, and secure way.
➞ 𝐈𝐦𝐩𝐥𝐞𝐦𝐞𝐧𝐭𝐞𝐝 a scalable 𝐝𝐚𝐭𝐚 𝐩𝐫𝐞𝐩𝐫𝐨𝐜𝐞𝐬𝐬𝐢𝐧𝐠 𝐩𝐢𝐩𝐞𝐥𝐢𝐧𝐞 that supports multiple media types (images, videos, audio, 3D objects) and creates small preview files that are cheap to transfer, store and visualize. The 𝐨𝐫𝐢𝐠𝐢𝐧𝐚𝐥 𝐟𝐢𝐥𝐞𝐬 are 𝐚𝐫𝐜𝐡𝐢𝐯𝐞𝐝 on an affordable storage solution 𝐫𝐞𝐝𝐮𝐜𝐢𝐧𝐠 𝐜𝐨𝐬𝐭𝐬 𝐛𝐲 𝐮𝐩 𝐭𝐨 𝟖𝟏%.

I'm currently designing a second brain AI agent.

Here's a high-level architecture (steal it and build your own):

The goal is to create an agent that can reason over everything I’ve ever written, watched, or saved while automatically picking up facts, events, and preferences about me.

The agent should then utilize that memory to assist me in writing, thinking, and creating.

At the foundation of everything happening is GraphRAG.

Then we have 3 steps:

𝟭/ 𝗜𝗻𝗴𝗲𝘀𝘁𝗶𝗼𝗻 = 𝗺𝗲𝗺𝗼𝗿𝘆

All notes, documents, and links flow through a GraphRAG ingestion pipeline:
 
• Extract entities and relationships
• Summarize and embed content
• Store it as a knowledge graph

This gives me three retrieval modes: semantic search, metadata search, and graph traversal.

That’s how the agent can respond to queries like, “Write a section on building a modular MCP server.”

→ Find MCP-related notes
→ Traverse connected ideas 1–2 hops away.

We then orchestrate the entire pipeline using Prefect, which gives us durable workflows with scheduling, retries, monitoring, and failure recovery.

𝟮/ 𝗔𝗴𝗲𝗻𝘁𝗶𝗰 𝗿𝗲𝘁𝗿𝗶𝗲𝘃𝗮𝗹

On top of that memory sits the agent.

It can:
 
• Query the knowledge graph
• Update long-term memory (episodic, semantic, procedural)
• Call external tools like web search or image generation
• Use a smaller fine-tuned “LLM twin” to match writing style

The agent automatically learns my preferences, facts, and events and writes them back into the knowledge graph.

So it never reasons over everything.
It retrieves only the relevant slice of memory.

This inference loop is also orchestrated with Prefect, this time to make agent calls durable: retries, monitoring, and scalable inference.

𝟯/ 𝗦𝗲𝗿𝘃𝗶𝗻𝗴 𝘃𝗶𝗮 𝗠𝗖𝗣

The agent is exposed as an MCP server using FastMCP (by Prefect).

This lets me interact with it directly from tools like Claude or Cursor, refining ideas conversationally instead of relying on one-shot prompts.

𝗧𝗵𝗲 𝗰𝗼𝗿𝗲 𝗶𝗱𝗲𝗮 𝗶𝘀 𝘁𝗵𝗶𝘀:

Effective agents are built with structured memory + reliable orchestration.

P.S. Have you tried to build a Second Brain Agent yet?

Senior AI Engineer • Founder @ Decoding AI • Author @ LLM Engineer’s Handbook ~ I ship AI products and teach you about the process.

If you’re building AI agents in 2026,

You need a faster way to make architecture decisions...

95% of agents never hit production.

And it's because teams pick the wrong architecture from day one.

They use workflows when they need an agent.
Multi-agent when a simple pipeline would have worked.
Autonomy where determinism was enough.

So we created something to help with that...

Introducing, Building AI Agents Architecture Cheat Sheet.

It was created by Louis-François Bouchard from Towards AI, Inc. in collaboration with me for our Agentic AI Engineering course that's coming this month.

The idea was to help you make the best architecture decisions.

Specifically, here's what it helps you do:
 
• Decide Workflow vs Single Agent vs Multi-Agent based on real constraints
• Avoid unnecessary autonomy that explodes cost, latency, and debugging time
• Apply the Autonomy Test to know when you actually need an agent
• Design thin agents + heavy tools for reliability
• Add validation loops, observability, and human in the loop (HITL) by design
• Pick the minimum architecture that works before scaling complexity

It also includes:
 
• A practical kickoff decision process
• Architecture questions with concrete build outcomes
• Clear signals for when multi-agent systems actually make sense
• Production rules we use when shipping real agentic systems

This is exactly the kind of reference you want before you write any code.

If you want it, here's how to get it...
 
Link: https://lnkd.in/eb_V3ck7

P.S. Huge credit to Louis-François Bouchard and the Towards AI, Inc. team for putting this cheatsheet together.

I noticed something interesting after publishing LLM Engineers Handbook:

AI engineering is still widely misunderstood.

Many people expected the book to be a step-by-step guide to fine-tuning LLMs.

And this makes sense to an extent...

Fine-tuning is the most visible part of the AI stack.

But this is not what makes you an AI engineer.
It's just part of the stack.

In fact, it's a small commoditized part of the snack.

These days, frameworks like Unsloth AI, Axolotl, and TRL from Hugging Face make fine-tuning relatively straightforward.

The real engineering work is about:
 
• Designing data pipelines that reliably collect, clean, and transform data
• Building infrastructure that scales, recovers, and stays observable
• Orchestrating RAG pipelines, agents, and workflows
• Managing datasets, lineage, evaluations, and monitoring in production

In other words, data is the bottleneck.

If you fine-tune on a random dataset and run a cookbook script, you have learned the “hello world” of fine-tuning.

The challenge is knowing what data you need, how to get it, how to structure it, and how to keep it fresh as systems evolve.

So if you want to grow as an AI or LLM engineer, your focus must shift.

Stop asking, “How do I fine-tune this model?”

Start asking, “How do I build a system that feeds the model the right data, at the right time, reliably?”

This is where production systems succeed or fail

Model architecture tweaks and novel training tricks are important, but that work sits closer to research than engineering.

Both matter.
They are just different jobs.

AI engineering is about shipping systems that work, scale, and survive real users and real data.

And once you see that clearly, your learning priorities change completely.

GraphRAG is becoming mandatory for shipping real-world AI agents.

Here’s why:

Shipping reliable AI agents is mostly a data and memory problem.

But the majority of engineers still treat it like a prompting issue.

An agent fails, and the instinctive reaction is:

“Rewrite the prompt.”
“Add more instructions.”
“Increase the context window.”

Sometimes that helps.
Most of the time, it doesn’t.

Because modern agents rarely fail due to a lack of reasoning power...

They fail because they’re forced to reason over too much, too little, or the wrong context.

As systems grow, context fragments:
 
• Knowledge lives across docs, tickets, dashboards, and chat logs
• Ownership and dependencies exist only in people’s heads
• Old workarounds outlive their original intent
• Stale or irrelevant data quietly pollutes the context window

Longer context windows didn’t fix this...
They just made the problem easier to hide.

Performance degrades.
Contradictions creep in.
The agent repeats itself, hallucinates, or acts on outdated assumptions.

This has a name: context rot.

The real questions shouldn't be towards the prompts.

They should be targeted at the architecture:
 
• How do you store organizational knowledge long-term?
• How do you retrieve only what’s relevant right now?
• How do you prevent bad data from contaminating the context window?
• How do you connect memory, ownership, dependencies, and history?

This is where knowledge graphs and GraphRAG become essential.

Instead of dumping documents into a prompt, you model your domain: services, teams, incidents, decisions (and how they relate).

This is exactly what I'll walk through at AI Superstream: Context Engineering by O’Reilly.

Specifically, we'll cover:
 
• When vanilla RAG is not enough
• How knowledge graphs act as long-term memory for agents
• How GraphRAG keeps context windows small but meaningful
• How to design agent memory that scales in real systems

If you’re building agents meant to survive real users, real data, and real time, this layer is non-negotiable.

Prompting is the surface.
Context engineering is the foundation.

📆: 26th February 2026

🔗: https://lnkd.in/exndWkcS

P.S. Seats are limited.

P.S.S. Huge thank you to Angelina Yang for inviting me to this panel and to O'Reilly for making this event possible.

Most production incidents aren’t hard to fix.

But they are hard to understand.

By the time an alert fires, the problem usually isn’t new…

Someone has seen it before.
There’s a workaround.
There’s history.

But that context is scattered across Slack threads, old runbooks, dashboards, and people’s heads.

As systems grow, this becomes the real failure mode.

Not broken code.
Broken memory.

And this is exactly why GraphRAG matters in production systems.

Without graph-based memory, engineers lose time reconstructing what the organization already knows, instead of fixing the issue at hand.

The way out isn’t more alerts or better dashboards…

It’s designing agents that carry organizational memory.

In the latest episode of Decoding AI Magazine, I walk through how to design a Production Engineer agent that reacts to alerts by:
 
• Identifying affected services and teams
• Understanding how failures propagate through dependencies
• Surfacing the context engineers usually spend hours digging for

The key insight is memory.

We use GraphRAG to model services, teams, incidents, and documentation as a connected system the agent can traverse when it matters most.

If you’re building agentic systems for production environments, this is the mental model that holds up at scale.

The full breakdown will go live tomorrow at 1 PM CET.

Subscribe to Decoding AI Magazine to get it delivered to your inbox.

Link → https://lnkd.in/et8fmmBQ

I was a true believer in clean architecture.

I honestly thought it would help me structure my Python AI projects.

This resulted in countless hours wasted obsessively dividing my projects into four folders:
 
• Domain
• Application
• Infrastructure
• Interface

It felt right.
But it was a complete nightmare to maintain.

It wasn’t until I realized that these layers should be virtual concepts that I finally cracked it.

Because Python doesn’t force structure on you.
It gives you freedom.

And that freedom is exactly why AI projects fall apart.

If you don’t impose some structure, you get spaghetti code.
If you impose too much structure, you get ceremony and friction.

Most advice pushes you to one extreme or the other.

Either rigid Clean Architecture, copied from Java, or tool-specific templates that lock you into a framework.

Neither worked for me.

What finally worked was treating clean architecture as a set of boundaries.

The domain became “pure business logic.”
The application became orchestration.
Infrastructure became swappable details.
Interfaces became replaceable entry points.

But none of that needed to be enforced dogmatically in folders.

Once I made that shift, things got simpler.

AI agents became reusable.
Workflows became easier to change.
Switching models or storage stopped rippling through the codebase.

If your Python AI project feels messy and fragile, or clean but painful to work in...

You’re probably applying the right ideas in the wrong way.

Btw, I wrote down the exact mental model and project structure that finally worked for me while building AI agents and workflows.

Sharing it here in case it helps someone else…

Link: https://lnkd.in/eGsU7ww3

P.S. If clean architecture ever made your Python project worse before it made it better, you’re not alone :)

I created an AI agent to write a Substack post (and it went viral).

Nobody even noticed it was AI. The secret?

How we evaluated the agent.

Most people think creating accurate agents is about prompt magic, but that's not the case.

Your evaluation process can make or break everything.

So here's the exact framework we used:

𝟭/ 𝗦𝘁𝗮𝗿𝘁 𝘄𝗶𝘁𝗵 𝘁𝗵𝗲 𝗯𝘂𝘀𝗶𝗻𝗲𝘀𝘀 𝘂𝘀𝗲 𝗰𝗮𝘀𝗲

You can’t design agents or evals in the abstract.

For us, the requirements were explicit:
 
• 10–20 minute technical articles
• Markdown output
• Clear structure and narrative flow
• Mermaid diagrams
• Grounded research

The agent wasn’t allowed to “be creative.”
It was either correct or incorrect.

𝟮/ 𝗧𝗿𝗮𝗻𝘀𝗹𝗮𝘁𝗲 𝗿𝗲𝗾𝘂𝗶𝗿𝗲𝗺𝗲𝗻𝘁𝘀 𝗶𝗻𝘁𝗼 𝗯𝗶𝗻𝗮𝗿𝘆 𝗰𝗵𝗲𝗰𝗸𝘀

We didn’t use vague 1–5 scores.

We wrote yes/no metrics:
 
• Did the structure match expectations?
• Did it follow the storyline?
• Did it stay grounded in provided research?
• Were diagrams, code blocks, and formatting correct?

Binary metrics force clarity.
They also make finding failures easier and debuggable.

𝟯/ 𝗦𝗲𝗽𝗮𝗿𝗮𝘁𝗲 𝗴𝗿𝗼𝘂𝗻𝗱 𝘁𝗿𝘂𝘁𝗵 𝗳𝗿𝗼𝗺 𝗻𝗼𝗻-𝗴𝗿𝗼𝘂𝗻𝗱 𝘁𝗿𝘂𝘁𝗵

Some things can be checked directly.
Others can’t.

So we designed two layers:
 
• With ground truth: direct comparison to references
• Without ground truth: style, input coherence, topicality

Both matter.

One anchors the system.
The other preserves flexibility where it’s needed.

𝟰/ 𝗕𝘂𝗶𝗹𝗱 𝗮𝗻 𝗟𝗟𝗠-𝗮𝘀-𝗮-𝗷𝘂𝗱𝗴𝗲

Each metric had:
 
• A custom prompt
• 20–30 few-shot examples
• A binary decision
• A written reason

Why?

It tells you why something failed, not just that it did.

𝟱. 𝗘𝘃𝗮𝗹𝘂𝗮𝘁𝗲 𝘁𝗵𝗲 𝗲𝘃𝗮𝗹𝘂𝗮𝘁𝗼𝗿

We labeled another 20–30 samples ourselves.

Human vs model agreement became the metric.

Once that loop was stable, iteration became engineering:
 
• Swap models
• Push changes
• Score outputs
• Debug with confidence

This framework scales to any agent system.

And it’s exactly the kind of thinking we go deep on in the Agentic AI Engineering course.

We’ll be going live in February 🚀

If you want to learn how to:
 
• Build agents with real evaluation layers
• Design LLM-as-judge systems correctly
• Move from “it works” to “it’s reliable”
 
Join the waitlist here → https://lnkd.in/dtxZuZpb
 
P.S. If you’re building agents without evals, you’re in for a bumpy ride.

In 4 days, I will be live on the DataTalksClub podcast, taking live QAs on AI Engineering, Skill Stack, Agents, LLMOps, and How to Ship AI Products.

Together with Alexey Grigorev we will chat about: 

• The principles behind production-grade systems
• How to build reliable agentic workflows​
• ​The LLMOps practices that keep models stable​
• ​​The patterns I've learned from building more than 20 AI applications

Plus answering all your amazing questions!

The podcast is live, virtual and FREE on 26 Jan.

Join here: https://luma.com/fx3wplwn

See you there ✌️

Thank you Alexey Grigorev for inviting me! So excited about this one.

FastMCP is the best way to build or hook to MCP servers nowadays. At agent-to-tools or even agent-to-agent communication (where an agent is exposed as a tool), MCP is the clear winner. That's why I'm super thrilled to see how quickly FastMCP is adapting to this change with their dynamic features included in their freshly baked 3.0 version.

DAY 1: FastMCP 3.0 Beta is live 🚀

We’re kicking off this week with a rebuild of the FastMCP foundation.

The foundation is rebuilt to move beyond simple tool scripts and into composable AI infrastructure.

𝙼𝚊𝚓𝚘𝚛 𝚄𝚙𝚍𝚊𝚝𝚎𝚜 👇
🔌 Provider Architecture: A unified system that replaces duplicated code across features for flexible, dynamic server building.

👤 Dynamic Scoping: Servers can now show different tools to different users from a single endpoint.

🧩 Composite Apps: Combine tools from data, platform, and product teams into one authorized interface without collisions.

🔍  Context Optimization: New features for search, curation, and progressive disclosure to keep agent context windows clean.

💡 Agent Skills: Direct instructions on how and when an agent should use specific tools.

𝙱𝚊𝚌𝚔𝚠𝚊𝚛𝚍 𝙲𝚘𝚖𝚙𝚊𝚝𝚒𝚋𝚒𝚕𝚒𝚝𝚢: The core Pythonic API remains the same. This rebuild adds the infrastructure required for dynamic environments without breaking your current v2 servers.

🚀 Install the beta: 𝐩𝐢𝐩 𝐢𝐧𝐬𝐭𝐚𝐥𝐥 𝐟𝐚𝐬𝐭𝐦𝐜𝐩==𝟑.𝟎.𝟎𝐛𝟏
💬 Join the Discord: https://lnkd.in/gVH4jZvE
📖 Docs: https://lnkd.in/dCH4cFmA
📝 Announcement Blog: https://lnkd.in/gWx24H_r
✨ What's New Blog: https://lnkd.in/ghQDjqQF

𝒪𝓃ℯ 𝓂ℴ𝓇ℯ 𝓉𝒽𝒾𝓃ℊ.

FastMCP is how you BUILD MCP servers.

Tomorrow we're showing you how you take them to a whole new level. 🌅

I am an ambitious Senior AI Engineer, with 10 years of experience in the Software Development industry. 

My passion for Artificial Intelligence research and development ignited at its very beginning in Europe. Since then, I’ve been keen on architecting, designing, and implementing top-of-the-line software solutions tailored to the unique needs of businesses.

My commitment to staying at the forefront of technological advancements has enabled me to exceed the evolving demands of the digital business landscape.

My biggest differentiator is my expertise - based upon best practices study, a non-conventional approach that goes beyond the latest tech trends, and proven solutions that best fit business objectives.

Whether we’re talking about Product Development, driving projects as a Contractor, or offering my input as a Freelancer, I’m enthusiastic about delivering results that transcend expectations. 

My proficiency in AI, MLOps, and System Architecture are not just skill sets. They are components that bridge the gap between real-world solutions and advanced algorithmic strategies.

🎯 Open for remote work in Romania and internationally. 
🎯 Desire for challenging tech projects that want to upscale business goals.
🎯 Aligning technology, business, and leadership into a comprehensive vision.


💻 Technical experience

◾ Programming languages: Python, Node.js, SQL, Go

◾ Technologies: 
• PyTorch, Tensorflow, Keras
• NumPy, Pandas, OpenCV, CUDA
• AWS, 
• Docker
• Django, Flask, FastAPI, 
• Kafka
• Weights & Biases, MLFlow, Langfuse
• PostgreSQL, Elasticsearch, Redis
• Qdrant, Chroma
• Terraform, CDK

◾ Tech products // Niches:
• Night Vision System with Convolutional Neural Networks (Automotive)
• Social Media Post Generator with LLMs (Consumer Services)
• Organs at Risk segmentation with 2.5/3D Convolutional Neural Networks (Medtech)
• AI-powered workspace that turns data chaos into structured data with LLMs and OCR system (Medtech)


Let's connect and explore how I can contribute to the success of your business by bringing expertise, innovation, and a proven track record to the table.

Alex Vesa

RAG and I got back together. 💀

𝐇𝐞𝐫𝐞'𝐬 𝐬𝐨𝐦𝐞𝐭𝐡𝐢𝐧𝐠 𝐦𝐨𝐬𝐭 𝐑𝐀𝐆 𝐭𝐮𝐭𝐨𝐫𝐢𝐚𝐥𝐬 𝐰𝐨𝐧'𝐭 𝐭𝐞𝐥𝐥 𝐲𝐨𝐮: 𝐞𝐦𝐛𝐞𝐝𝐝𝐢𝐧𝐠 𝐭𝐚𝐛𝐥𝐞 𝐇𝐓𝐌𝐋 𝐝𝐢𝐫𝐞𝐜𝐭𝐥𝐲 𝐦𝐚𝐭𝐜𝐡𝐞𝐝 𝐪𝐮𝐞𝐫𝐢𝐞𝐬 𝟑𝟎% 𝐨𝐟 𝐭𝐡𝐞 𝐭𝐢𝐦𝐞. 

Embedding flattened prose from the same tables matched 85%. 

Same content, different representation, nearly 3x the retrieval accuracy. 

What most RAG tutorials don't tell you: 👇 

𝐎𝐂𝐑 𝐢𝐬𝐧'𝐭 𝐞𝐧𝐨𝐮𝐠𝐡: Treating pages as images lets Vision LLMs catch extraction errors that text-only processing misses entirely.

𝐓𝐚𝐛𝐥𝐞𝐬 𝐧𝐞𝐞𝐝 𝐭𝐰𝐨 𝐫𝐞𝐩𝐫𝐞𝐬𝐞𝐧𝐭𝐚𝐭𝐢𝐨𝐧𝐬: Structured HTML for display, flattened prose for semantic search.

𝐂𝐨𝐧𝐭𝐞𝐱𝐭 𝐟𝐥𝐨𝐰𝐬 𝐚𝐜𝐫𝐨𝐬𝐬 𝐩𝐚𝐠𝐞𝐬: A table that starts on page 35 is still relevant on page 36. Process pages together or lose the relationships.

𝐌𝐞𝐭𝐚𝐝𝐚𝐭𝐚 𝐢𝐬 𝐧𝐨𝐭 optional: Rich domain-specific metadata improved retrieval accuracy by 27% in my tests.

𝐈𝐦𝐚𝐠𝐞𝐬 𝐧𝐞𝐞𝐝 𝐜𝐥𝐚𝐬𝐬𝐢𝐟𝐢𝐜𝐚𝐭𝐢𝐨𝐧: Without it, a query for "schematic" returns logos and photos with equal confidence.

𝐏𝐚𝐫𝐬𝐞 𝐬𝐭𝐫𝐮𝐜𝐭𝐮𝐫𝐞, 𝐝𝐨𝐧'𝐭 𝐠𝐞𝐧𝐞𝐫𝐚𝐭𝐞 𝐢𝐭: LLMs will invent document structure if you ask them to infer it. Extract it from the actual PDF instead.

Full implementation on GitHub. Link in comments 👇

📄 Part 1: Why the Hell Should I Build This?: https://lnkd.in/dhfcymRQ
📄 Part 2: Data Modeling for RAG That Works: https://lnkd.in/djHweF83
📄 Part 3: From Principles to Production Code: https://lnkd.in/d-f_Db3x
💻 GitHub: Complete implementation https://lnkd.in/drsiuJYH

𝐒𝐡𝐞 𝐞𝐱𝐩𝐞𝐜𝐭𝐞𝐝 𝐬𝐨 𝐦𝐮𝐜𝐡 𝐦𝐨𝐫𝐞 𝐟𝐫𝐨𝐦 𝐦𝐞. 

But 23% retrieval accuracy doesn't lie.

I'm talking about Qdrant. My vector database. Get your mind out of the gutter.

I spent 3 weeks building an AI system, and the whole thing was broken from day one. 
I picked LlamaIndex because everyone uses it, set up Qdrant because it's popular, fine-tuned Llama 3.2 because fine-tuning sounds impressive. 

The retrieval returned irrelevant chunks, the fine-tuned model overfitted to old content, and the pipeline looked great on paper while failing silently in production.

The mistake was asking "what tools should I use?" instead of "where can this system fail my users?"

So I rebuilt it from first principles. 

The new architecture has four phases: 
🩸Ingestion with Llama 3.2 Vision for OCR
🩸Finetuning with dataset versioning in Langfuse
🩸Retrieval with query decomposition and reranking
🩸Generation with the fine-tuned model.

Every component now has to answer where it can fail and how I'll know when it does:
↳ Corrupt data in ingestion → garbage retrieval downstream → added data validation before anything hits MongoDB 
↳ Overfitted fine-tuning → model sounds like 2023 → track every experiment, version every dataset 
↳ Bad retrieval → hallucinations → monitor embedding drift, filter by metadata before reranking 
↳ No prompt versioning → can't debug why generation quality dropped → log everything in Langfuse

That's the actual work of MLOps, not picking between Kubeflow and MLflow, not building fancy dashboards, but ensuring reproducibility when you retrain tomorrow, scalability when traffic spikes, and observability when the model starts hallucinating at 2am and nobody notices until a client complains.

The thinking process is more important than tools.

Full article with code and architecture breakdown ↓
🔗 https://lnkd.in/d_U8n3Np

𝐈 𝐬𝐩𝐞𝐧𝐭 𝐲𝐞𝐚𝐫𝐬 𝐭𝐫𝐞𝐚𝐭𝐢𝐧𝐠 𝐌𝐋 𝐬𝐲𝐬𝐭𝐞𝐦𝐬 𝐥𝐢𝐤𝐞 𝐜𝐨𝐝𝐞. 𝐁𝐮𝐢𝐥𝐝 𝐚 𝐦𝐨𝐝𝐞𝐥. 𝐃𝐞𝐩𝐥𝐨𝐲 𝐢𝐭. 𝐌𝐨𝐯𝐞 𝐨𝐧.

Then I read Jim Dowling new O'Reilly book and realized I was solving the wrong problem.

The book's central insight: any AI system—batch, real-time, or agentic—can be decomposed into three pipelines connected by a feature store.

Feature pipelines transform raw data into features. Training pipelines turn features into models. Inference pipelines use models to make predictions.

The feature store connects them all. Same features for training and inference. No skew. No drift. No, "it worked in my notebook."

𝐖𝐡𝐚𝐭 𝐡𝐢𝐭 𝐦𝐞 𝐡𝐚𝐫𝐝𝐞𝐬𝐭:

𝐒𝐭𝐚𝐭𝐢𝐜 𝐝𝐚𝐭𝐚𝐬𝐞𝐭𝐬 𝐝𝐨𝐧'𝐭 𝐞𝐱𝐢𝐬𝐭 𝐢𝐧 𝐩𝐫𝐨𝐝𝐮𝐜𝐭𝐢𝐨𝐧. ML courses train on train.csv and test on test.csv. Production systems see new rows hourly, GDPR deletion requests weekly, and feature values that shift as user behavior changes. 
The book covers incremental updates, backfilling, and data validation with Great Expectations.

𝐑𝐞𝐚𝐥-𝐭𝐢𝐦𝐞 𝐌𝐋 𝐮𝐬𝐞𝐬 𝐭𝐡𝐞 𝐬𝐚𝐦𝐞 𝐚𝐫𝐜𝐡𝐢𝐭𝐞𝐜𝐭𝐮𝐫𝐞 𝐚𝐬 𝐛𝐚𝐭𝐜𝐡. TikTok computes features from recent clicks, historical preferences, and trending content. Spotify's weekly playlist runs the same computation on a slower schedule. Latency changes. Architecture doesn't.

𝐋𝐋𝐌𝐬 𝐫𝐞𝐪𝐮𝐢𝐫𝐞 𝐟𝐞𝐚𝐭𝐮𝐫𝐞 𝐞𝐧𝐠𝐢𝐧𝐞𝐞𝐫𝐢𝐧𝐠. Context engineering for agents follows the same pipeline pattern as feature engineering for classical models. RAG systems retrieve features from document stores or feature stores. Chapter 12 covers LlamaIndex, retrieval-augmented generation, and the Model Context Protocol.

Endorsed by:
Ritchie Vink (creator of Polars)
Erik Bernhardsson (CEO of Modal

If you're tired of models that work in notebooks but fail in production, this is the architecture book.

You can find the book here:

Open article: O'Reilly Book - Building Machine Learning Systems | Hopsworks by hopsworks.ai

O'Reilly Book - Building Machine Learning Systems

O'Reilly Book - Building Machine Learning Systems | Hopsworks

𝐒𝐭𝐨𝐩 𝐥𝐞𝐭𝐭𝐢𝐧𝐠 𝐋𝐋𝐌 𝐭𝐢𝐦𝐞𝐨𝐮𝐭𝐬 𝐤𝐢𝐥𝐥 𝐲𝐨𝐮𝐫 𝐩𝐫𝐨𝐝𝐮𝐜𝐭𝐢𝐨𝐧 𝐩𝐢𝐩𝐞𝐥𝐢𝐧𝐞𝐬. 🛑

We’ve all been there: You build a batch processing script that works perfectly for 10 items. Then a customer sends 500, and everything breaks at 3 AM.

Lambda times out. Logs are a mess. Half the data is gone, and you have no idea where the process stopped.

In the latest deep-dive from The Neural Maze, me and Miguel Otero Pedrido break down a "Fan-Out" architecture that turned a failing 60-minute sequential process into a reliable 8-minute parallel system.

The 5-step blueprint for reliable LLM Batching:

1️⃣ 𝐒𝐞𝐩𝐚𝐫𝐚𝐭𝐞 𝐎𝐫𝐜𝐡𝐞𝐬𝐭𝐫𝐚𝐭𝐢𝐨𝐧 𝐟𝐫𝐨𝐦 𝐄𝐱𝐞𝐜𝐮𝐭𝐢𝐨𝐧: Don't let a Lambda orchestrate itself. Use ECS as the "patient coordinator" that can wait 40+ minutes, while Lambdas act as high-speed parallel workers. 
2️⃣ 𝐓𝐡𝐞 "𝐒𝐰𝐞𝐞𝐭 𝐒𝐩𝐨𝐭" 𝐁𝐚𝐭𝐜𝐡 𝐒𝐢𝐳𝐞: Don't process 1 by 1 (too much overhead) or 50 by 50 (timeout risk). The article found 15 items per batch was the magic number for 30s LLM calls. 
3️⃣ 𝐒𝐭𝐨𝐩 𝐀𝐛𝐮𝐬𝐢𝐧𝐠 𝐲𝐨𝐮𝐫 𝐕𝐞𝐜𝐭𝐨𝐫 𝐃𝐁: Don’t use Qdrant or Pinecone as a blob store for large payloads. Store the heavy data in S3 and let the Lambdas fetch only what they need. 
4️⃣ 𝐀𝐭𝐨𝐦𝐢𝐜 𝐂𝐨𝐨𝐫𝐝𝐢𝐧𝐚𝐭𝐢𝐨𝐧 𝐰𝐢𝐭𝐡 𝐑𝐞𝐝𝐢𝐬: Avoid race conditions. Use Redis atomic counters (INCR) to track when all parallel workers are done so the orchestrator knows exactly when to aggregate results. 
5️⃣ 𝐏𝐚𝐫𝐭𝐢𝐚𝐥 𝐒𝐮𝐜𝐜𝐞𝐬𝐬 𝐢𝐬 𝐬𝐭𝐢𝐥𝐥 𝐒𝐮𝐜𝐜𝐞𝐬𝐬: Treat failures as a first-class state. If 12 out of 127 deals fail, don't kill the job. Save the 115 successful results and flag the errors.

The Result? 127 events analyzed in 8 minutes instead of 63. No timeouts. Total visibility.

If you’re moving from "AI Prototype" to "Production System," this is a must-read.

Read the full technical breakdown here: https://lnkd.in/dMxVgi-R

𝐈 𝐬𝐩𝐞𝐧𝐭 𝟐 𝐦𝐨𝐧𝐭𝐡𝐬 𝐫𝐞𝐚𝐝𝐢𝐧𝐠 𝟐𝟎𝟐𝟓 𝐑𝐀𝐆 𝐫𝐞𝐬𝐞𝐚𝐫𝐜𝐡 𝐩𝐚𝐩𝐞𝐫𝐬 𝐬𝐨 𝐲𝐨𝐮 𝐝𝐨𝐧'𝐭 𝐡𝐚𝐯𝐞 𝐭𝐨.

Here's what I found: metadata for the RAG systems 𝐢𝐬 𝐧𝐨𝐭 𝐨𝐩𝐭𝐢𝐨𝐧𝐚𝐥. 

It's the difference between real world systems and shitty demos/toys.

The papers:

𝐌𝐮𝐥𝐭𝐢-𝐌𝐞𝐭𝐚-𝐑𝐀𝐆 (𝐏𝐨𝐥𝐢𝐚𝐤𝐨𝐯 & 𝐒𝐡𝐯𝐚𝐢, 𝐈𝐂𝐓𝐄𝐑𝐈 𝟐𝟎𝟐𝟒/𝐒𝐩𝐫𝐢𝐧𝐠𝐞𝐫 𝟐𝟎𝟐𝟓) LLM-extracted metadata fields. improved accuracy by 26% with Google PaLM and 12% with GPT-4 on MultiHop-RAG benchmark → https://lnkd.in/dBESKYXd

𝐑𝐀𝐆𝐌𝐀𝐓𝐄 (𝐕𝐢𝐫𝐠𝐢𝐧𝐢𝐚 𝐓𝐞𝐜𝐡, 𝐄𝐂𝐈𝐑 𝟐𝟎𝟐𝟔) Tested on SEC 10-K filings where similar language across documents confounds pure semantic retrieval. Context@5 accuracy jumped from 33.33% to 63.33% when metadata was unified with embeddings. Retrieval failure rates dropped from 10% to 3.33% → https://lnkd.in/dcHTnvfx

𝐀𝐧𝐭𝐡𝐫𝐨𝐩𝐢𝐜'𝐬 𝐂𝐨𝐧𝐭𝐞𝐱𝐭𝐮𝐚𝐥 𝐑𝐞𝐭𝐫𝐢𝐞𝐯𝐚𝐥 (𝐒𝐞𝐩𝐭𝐞𝐦𝐛𝐞𝐫 𝟐𝟎𝟐𝟒, 𝐮𝐩𝐝𝐚𝐭𝐞𝐝 𝟐𝟎𝟐𝟓) Prepending contextual snippets to chunks before embedding + combining with BM25 dropped retrieval failure rates from 5.7% to 1.9%. A 67% reduction. → https://lnkd.in/d_hy8Gr4

𝐋𝐀𝐃-𝐑𝐀𝐆 (𝐎𝐜𝐭𝐨𝐛𝐞𝐫 𝟐𝟎𝟐𝟓) Tackles cross-page dependencies in visually-rich documents. Over 90% perfect recall without top-k tuning. Up to 20% recall improvement over baseline retrievers on MP-DocVQA and DUDE benchmarks. → https://lnkd.in/dNqFWAma

𝐓𝐚𝐛𝐥𝐞𝐑𝐀𝐆 (𝐍𝐞𝐮𝐫𝐈𝐏𝐒 𝟐𝟎𝟐𝟒, 𝐆𝐨𝐨𝐠𝐥𝐞 𝐑𝐞𝐬𝐞𝐚𝐫𝐜𝐡) Cell-level encoding for tables with millions of tokens. Cell retrieval alone provides 11.5% improvement in extracting key information that row-column retrieval misses. → https://lnkd.in/dV_8_qSf

𝐑𝐃𝐑𝟐 (𝐄𝐌𝐍𝐋𝐏 𝟐𝟎𝟐𝟓 𝐅𝐢𝐧𝐝𝐢𝐧𝐠𝐬) Treats documents as navigable hierarchies through Document Structure Trees. State-of-the-art on TriviaQA, HotpotQA, QAMPARI, and ASQA by jointly evaluating content relevance AND hierarchical relationships. → https://lnkd.in/dmzAMwQh

𝐒𝐈𝐆𝐈𝐑 𝐋𝐢𝐯𝐞𝐑𝐀𝐆 Challenge 2025 25 teams, 10-billion-token corpus. Hybrid BM25 + dense retrieval with neural reranking improved MAP from 0.523 to 0.797. A 52% relative improvement. → https://lnkd.in/dnguhjRz

The pattern across all of them:

🩸Metadata filtering before semantic search
🩸Hybrid retrieval (sparse + dense) beats either alone by 15-52%
🩸Document structure preservation yields 10-20% gains
🩸Domain-specific fields (model number, company name, date) matter more than generic metadata (filename, author)

I wrote a complete implementation with working code:
→ 𝐃𝐚𝐭𝐚 𝐌𝐨𝐝𝐞𝐥𝐢𝐧𝐠 𝐟𝐨𝐫 𝐑𝐀𝐆 𝐓𝐡𝐚𝐭 𝐖𝐨𝐫𝐤𝐬: https://lnkd.in/djHweF83
→ 𝐁𝐮𝐢𝐥𝐝𝐢𝐧𝐠 𝐑𝐀𝐆 𝐭𝐡𝐚𝐭 𝐰𝐨𝐫𝐤𝐬 𝐢𝐬 𝐛𝐨𝐫𝐢𝐧𝐠: https://lnkd.in/dVyQVqys

What metadata fields have made the biggest difference in your domain?

metadata_rag

𝐀𝐖𝐒 𝐋𝐚𝐦𝐛𝐝𝐚 𝐚𝐧𝐝 𝐈 𝐡𝐚𝐝 𝐚 𝐟𝐢𝐠𝐡𝐭. 💀

I asked it to process 127 items. It processed 29 and died at 14:58. No partial results. No way to resume. Just "Task timed out after 900.00 seconds."

We needed couples therapy. 

𝐈𝐭'𝐬 𝐜𝐚𝐥𝐥𝐞𝐝 𝐟𝐚𝐧-𝐨𝐮𝐭.

Here's what changed when I stopped asking "how do I process this faster?" and started asking "what happens when it breaks?"

The client needed to analyze 127 sales deals. Each deal: 30 seconds of LLM calls. Sequential: 63.5 minutes. Lambda's limit: 15 minutes.

My old approach was highly dependent on how fast third-party APIs were.

My new approach: 7 decisions that respect the constraints.

1. ECS as orchestrator: Lambda can't wait. ECS can poll for 40 minutes if needed.

2. 15 deals per batch: Too small = coordination overhead. Too large = timeout. 7.5 minutes leaves 7.5 minutes buffer.

3. S3, not Qdrant: We tried storing bundles in Qdrant. 800ms per upsert. 100 seconds overhead. Ferrari hauling furniture.

4. Atomic counters in Redis: Two Lambdas finish at the same millisecond. Who triggers collection? INCR and SETNX. No race conditions.

5. Structured results: Each deal produces qualification scores, risk signals, and buying signals. 127 JSONs aggregated into one intelligence map.

6. Graceful failure: Batch 3 dies? Continue with 112/127 deals. Don't throw away good work.

7. Dynamic timeouts: 127 deals ≠ 500 deals. Scale wait time with workload size.

The old approach was comfortable. One Lambda, one loop.

The new one: 9 parallel batches, 8 minutes total, zero timeouts.

Same compute cost. 8x faster wall-clock time.

Sometimes you just need to stop fighting the constraints.

🔗 Full breakdown with logs and code in my latest article: https://lnkd.in/dw3_Ns8C

48 concepts.

That's how many I counted that I need to understand to read ONE paper.

𝐋𝐅𝐌𝟐 𝐓𝐞𝐜𝐡𝐧𝐢𝐜𝐚𝐥 𝐑𝐞𝐩𝐨𝐫𝐭 from Liquid AI.

Reading technical reports or research papers was always one of my secret weapons. Whenever I wanted to go deep into a new direction, this was my go-to strategy.

But understanding a research paper, especially today, is pretty hard. You need a lot of time and ambition, and you need to do extensive reverse engineering across multiple concepts.

It's easy to talk about a research paper, but nobody explains what you need to know first.

So I made a list:

𝗟𝗲𝘃𝗲𝗹 𝟭 — Transformer Fundamentals
□ Self-attention (Q, K, V)
□ Multi-Head Attention
□ KV Cache and why it grows
□ Feed-forward networks (MLP)
□ Layer normalization (pre vs post)
□ Residual connections

𝗟𝗲𝘃𝗲𝗹 𝟮 — Efficient Architectures
□ Grouped Query Attention (GQA)
□ RoPE embeddings
□ SwiGLU activation
□ Depthwise convolution
□ Causal convolution
□ Sliding window attention
□ QK-Norm

𝗟𝗲𝘃𝗲𝗹 𝟯 — State Space Models
□ SSM basics (h' = Ah + Bx)
□ S4 (Structured State Spaces)
□ Discretization (continuous → discrete)
□ Mamba / Selective SSM
□ Linear attention variants
□ Why SSMs struggle with retrieval

𝗟𝗲𝘃𝗲𝗹 𝟰 — Training Techniques
□ Knowledge distillation
□ KL divergence (forward vs reverse)
□ Temperature scaling
□ Top-K distillation
□ Support mismatch problem
□ Curriculum learning
□ DPO for alignment
□ Model merging (TIES, DARE)

𝗟𝗲𝘃𝗲𝗹 𝟱 — Edge Deployment
□ TTFT (Time to First Token)
□ Decode latency (ms/token)
□ Prefill vs decode throughput
□ Peak RSS (memory)
□ Quantization (Q4_0, Q4_K)
□ llama.cpp internals
□ ExecuTorch for mobile
□ CPU cache hierarchy (L1/L2/L3)

𝗟𝗲𝘃𝗲𝗹 𝟲 — LFM2 Specific
□ Hardware-in-the-loop search
□ Pareto frontier optimization
□ Gated short convolution block
□ Decoupled Top-K distillation
□ Bernoulli term vs conditional term

I've checked 31 out of 48.
17 is still in progress.

Understanding a paper takes time. It's better to build the right foundation, layer by layer.

From now on, I'll break down one concept at a time. 

One post. One idea. 
If you're diving into LFM2 or any technical paper, follow along.  

Paper: arxiv.org/abs/2511.23404

𝐌𝐢𝐜𝐫𝐨𝐬𝐨𝐟𝐭 𝐣𝐮𝐬𝐭 𝐨𝐩𝐞𝐧-𝐬𝐨𝐮𝐫𝐜𝐞𝐝 𝐚 𝐓𝐓𝐒 𝐬𝐲𝐬𝐭𝐞𝐦 𝐭𝐡𝐚𝐭 𝐠𝐞𝐧𝐞𝐫𝐚𝐭𝐞𝐬 𝟗𝟎-𝐦𝐢𝐧𝐮𝐭𝐞 𝐦𝐮𝐥𝐭𝐢-𝐬𝐩𝐞𝐚𝐤𝐞𝐫 𝐜𝐨𝐧𝐯𝐞𝐫𝐬𝐚𝐭𝐢𝐨𝐧𝐬.

VibeVoice dropped this month with 10.2k GitHub stars. The technical approach is worth understanding.

The core problem with long-form speech synthesis: context windows. Most TTS models struggle past a few minutes because audio tokens accumulate fast at typical frame rates (50-100 Hz).

VibeVoice runs at 7.5 Hz.

They built continuous speech tokenizers (acoustic and semantic) that preserve audio fidelity at this ultra-low rate. 

The architecture combines an LLM (Qwen2.5 1.5B) for dialogue understanding with a diffusion head for generating acoustic details—a next-token diffusion approach.

Two model variants:

The long-form model synthesizes conversations up to 90 minutes with 4 distinct speakers. Speaker consistency across that duration is the hard part most teams skip.

The realtime model hits ~300ms time-to-first-audio with streaming text input. Useful for voice agents where latency compounds.

What actually works:
🩸 English and Chinese
🩸Cross-lingual voice transfer
🩸Spontaneous singing (the demos are surprisingly good)

Current limitations:
🩸No overlapping speech modeling
🩸No background audio/music
🩸English and Chinese only

MIT licensed. Weights on HuggingFace.

For anyone building voice interfaces or podcast automation: this is the best open-source baseline I've seen for multi-speaker long-form synthesis. 

The 7.5 Hz tokenizer design alone is worth reading the technical report.

Link:

Open article: GitHub - microsoft/VibeVoice: Open-Source Frontier Voice AI by github.com

GitHub - microsoft/VibeVoice: Open-Source Frontier Voice AI

Yann LeCun just nuked the LLM hype from orbit.

The Turing Award winner left Meta. He's launching AMI Labs in Paris. And his thesis is simple:

𝐋𝐋𝐌𝐬 𝐰𝐢𝐥𝐥 𝐧𝐞𝐯𝐞𝐫 𝐠𝐞𝐭 𝐮𝐬 𝐭𝐨 𝐡𝐮𝐦𝐚𝐧-𝐥𝐞𝐯𝐞𝐥 𝐀𝐈. 𝐅𝐮𝐥𝐥 𝐬𝐭𝐨𝐩.

Here's what he said in his MIT Tech Review interview that should make every AI leader uncomfortable:

𝐎𝐧 𝐭𝐡𝐞 𝐬𝐜𝐚𝐥𝐢𝐧𝐠 𝐦𝐲𝐭𝐡: "People have had this illusion, or delusion, that it is a matter of time until we can scale LLMs up to having human-level intelligence, and that is simply false."

𝐎𝐧 𝐭𝐡𝐞 𝐫𝐞𝐚𝐥 𝐡𝐚𝐫𝐝 𝐩𝐫𝐨𝐛𝐥𝐞𝐦: "This is why we don't have a domestic robot that is as agile as a house cat, or a truly autonomous car."

𝐎𝐧 𝐡𝐮𝐦𝐚𝐧𝐨𝐢𝐝 𝐫𝐨𝐛𝐨𝐭𝐬: "Frankly, nobody, absolutely nobody, knows how to make those robots smart enough to be useful. Take my word for it."

His bet: World models (JEPA architecture) that learn abstract representations from video and sensor data—not text. Systems that can actually predict consequences.

The business angle is sharp: Europe wants a frontier AI company that isn't American or Chinese. Yann LeCun pitching sovereignty and open-source as the differentiator. VCs are buying in because startups are tired of being locked into proprietary models.

Meta might become their first client. The irony.

Three things I'm watching:

𝐈𝐧𝐝𝐮𝐬𝐭𝐫𝐢𝐚𝐥 𝐚𝐩𝐩𝐥𝐢𝐜𝐚𝐭𝐢𝐨𝐧𝐬. LeCun specifically mentioned steel mills, jet engines, chemical plants—complex systems with thousands of sensors where no holistic models exist today

𝐓𝐡𝐞 𝐭𝐚𝐥𝐞𝐧𝐭 𝐠𝐫𝐚𝐛. Already recruiting from OpenAI, DeepMind, and xAI. People who believe LLMs hit a ceiling

𝐓𝐡𝐞 𝐭𝐢𝐦𝐞𝐥𝐢𝐧𝐞. He's saying "not next year or two years from now" for human-level AI. That's a direct counter to the AGI-by-2027 crowd

Worth paying attention to.

What's your take, is the LLM paradigm hitting diminishing returns, or is LeCun fighting the last war?

Resources:
https://lnkd.in/ddSVrpY5
https://lnkd.in/du3PtfBv

𝐓𝐡𝐞 "𝟏𝟎𝟎𝐤 𝐒𝐭𝐚𝐫" 𝐋𝐞𝐬𝐬𝐨𝐧: 𝐖𝐡𝐚𝐭 𝐭𝐡𝐞 𝐎𝐩𝐞𝐧𝐂𝐥𝐚𝐰 𝐒𝐚𝐠𝐚 𝐓𝐞𝐚𝐜𝐡𝐞𝐬 𝐔𝐬 𝐀𝐛𝐨𝐮𝐭 𝐀𝐈 𝐒𝐞𝐜𝐮𝐫𝐢𝐭𝐲

In the last 72 hours, the AI world witnessed a "masterclass in chaos." 🦞

The project formerly known as Clawdbot (and briefly Moltbot) has officially rebranded as OpenClaw after hitting a record-breaking 100,000 GitHub stars.
 
But the journey wasn't just about growth, it was a high-stakes security wake-up call.

𝐓𝐡𝐞 "𝐇𝐢𝐠𝐡𝐥𝐢𝐠𝐡𝐭𝐬" (𝐨𝐫 𝐋𝐨𝐰𝐥𝐢𝐠𝐡𝐭𝐬):

🩸 Identity Hijack: A 10-second delay in social handle switching led to a $16M crypto scam under the project’s name.
🩸The "Localhost" Myth: Researchers found 1,000+ exposed servers due to a simple auth bypass (CVE-2026-22812).
🩸Prompt Injection: The realization that an AI with "hands" (shell access) can be tricked by a simple malicious email.

As Sivaram PG notes in his latest piece on DEV Community, this isn't just about a name change; it's a "reset" for how we think about agentic infrastructure. 

The core vision remains: Your assistant, your machine, your rules. But the 34 security commits released today prove that "cool" is no longer enough, it has to be hardened.

The "Age of Agents" has officially arrived, and it’s messy. 

Are we ready for it?

taplio

The Battle

Paul Iusztin

Alex Vesa

Followers

Posts

Engagements

Likes

Performance ScorePaul Iusztin's LinkedIn Performance

Performance ScoreAlex Vesa's LinkedIn Performance

Ready to grow your LinkedIn presence?

taplio

The Battle

Paul Iusztin

Alex Vesa

Followers

Posts

Engagements

Likes

Performance Score.css-goub6s{font-size:var(--chakra-fontSizes-md);font-weight:500;color:var(--chakra-colors-gray-600);display:block;margin-top:var(--chakra-space-1);}Paul Iusztin's LinkedIn Performance

Performance ScoreAlex Vesa's LinkedIn Performance

Ready to grow your LinkedIn presence?

Performance ScorePaul Iusztin's LinkedIn Performance