I’ve been working in AI for close to a decade, starting well before today’s LLM-driven wave.

My work is grounded in understanding AI across layers — from hardware, AI models, and data to system design, reliability, and scale. I approach AI as an end-to-end engineering problem: not just modeling, but how models interact with data, infrastructure, and real-world constraints.

Alongside this, I write The AI Merge, a technical newsletter on AI foundations and systems engineering, focused on clear thinking and practical system design rather than hype.

I’m currently building an AI Systems course, centered on end-to-end system design, for engineers who want a deeper, systems-first understanding of modern AI.

🗞️ Read The AI Merge: https://read.theaimerge.com

Alex Razvant

Read more code.

And fewer articles, tutorials, or surface-level books.

If you’re already a Software Engineer or AI / ML Engineer, one of the fastest ways to level up right now is to: 

Study how big AI teams write and ship code - in public. 

Many top companies and major contributors to the AI space have been open-sourcing their internal frameworks, kernels, or infrastructure libraries. 

You might feel overwhelmed by the rapid pace at which AI is going.
But this is a massive learning opportunity if you know where to look.

Learning doesn’t just happen from papers and tutorials, especially if you already build software.

It happens when you:
- Read real production code
- Study PRs or commit history
- See how teams structure repos, APIs, configs, tests

Check what gets reviewed, what gets rejected, and why.
This kind of learning will upgrade your engineering intuition. 

Here are some excellent codebases to learn from.

✅ From DeepSeek:
1. FlashMLA  - A library of high-performance attention kernels.
Link: https://buff.ly/XbFnPA7 

2. DeepEP - A Communication Library for high-throughput MoE workloads.
Link: https://buff.ly/3qxMc3S

3. 3FS - A Distributed Filesystem for AI Workloads, for AI training and inference.
Link: https://buff.ly/ovfW47A

✅ From NVIDIA:
1. Dynamo - A datacenter-scale Inference Serving Framework for GenAI workloads.
Link: https://buff.ly/WyAMzBz 

2. NeMo  -  A Scalable Generative AI Framework, for training and deploying LLMs and VLMs.
Link: https://buff.ly/L9KTuJp 

✅ From vLLM:
1. The vLLM Library  - One of the most popular LLM inference engines, designed for scale.
Link: https://buff.ly/GLCfoIM

✅ From SGLang:
1. The SGLang Engine - A high-performance serving engine for LLMs & multimodal models.
Link: https://buff.ly/m4HhsWQ 

✅ From llama.cpp
1. The llama.cpp Engine - A minimal C/C++ inference engine for LLMs with broad hardware support and quantization options.
Link: https://buff.ly/u9yaXwp

📌 Don't study everything, you won't be able to.

Instead, pay attention to:
⇾ Code structure & abstractions
How are core functionalities separated (core logic vs hardware-specific optimizations)?

⇾  PRs & commit history
What context do authors provide? How do reviewers push back?

⇾  Interfaces & public APIs
How are public APIs designed?

⇾  Tests & benchmarks
How do the test suites look? What CI pipelines do they have, profiling? 

Don’t just use these libraries. 
Read them.

That will build your intuition and help you get better at your craft, either as a curious learner or an engineer as part of a larger team at your job.

---
I distill my learnings with my audience on The AI Merge.
Check it here (subscribe if interested) https://buff.ly/2rwqlNL

Senior AI Engineer | Writing The AI Merge Newsletter | Helping Engineers Build AI Beyond Demos

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

Alex Razvant

Alex Vesa

Followers

Posts

Engagements

Likes

Performance ScoreAlex Razvant's LinkedIn Performance

Performance ScoreAlex Vesa's LinkedIn Performance

Ready to grow your LinkedIn presence?

taplio

The Battle

Alex Razvant

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);}Alex Razvant's LinkedIn Performance

Performance ScoreAlex Vesa's LinkedIn Performance

Ready to grow your LinkedIn presence?

Performance ScoreAlex Razvant's LinkedIn Performance