Armand Ruiz

Director Data Science & AI Elite

Leading the Product Management org for the AI Portfolio of products focused on Generative AI and Traditional ML. Products include: watsonx.ai and watsonx.gov

Vice President of AI Platform

I am building the world's largest team of 𝐀𝐈 𝐄𝐧𝐠𝐢𝐧𝐞𝐞𝐫𝐬 by

- Recruiting hundreds of new engineers around the globe
- Reskilling our existing talent
- Offering them top-quality training in new-generation AI

Responsible for Pre-Sales Generative AI Pilots with the new IBM watsonx.ai Platform.

Director watsonx team - Client Engineering

Director of the group IBM Data Science Elite team. We prove the value of IBM Watson solutions by co-creating pilots with our customers. I managed a team of 90+ data scientists that worked on 100s of complex AI implementations.

Director Data Science

I manage a rockstar team of Product Managers leading the product portfolio of IBM Watson AI products.

Product Director - Product Management, Watson Studio and Machine Learning

Leading new Data Science products for IBM

Lead Product Manager - IBM Data Science and Watson Machine Learning

Bring Open Source data science tech to IBM stack

Product Manager for Data Science Open Source Extensibility 

In charge of Data Science projects in EMEA

Data Science Advocate - IBM Data Science & Machine Learning

Support sales in Data Science opportunities

Technical Seller Data Science & Smarter Cities

Internship to bring new innovations to IBM

Intern - Technical Software Engineer, Extreme Blue

Vodafone

Optimize 3G network coverage using Data Science

Data scientist - Radio Optimization Engineering

Federació Catalana de Tennis

Tennis Coach

VP of Product - AI Platform @IBM

As the Director of AI Engineering at IBM, I lead the watsonx team, a global group of over 1,000 AI Engineers who work on cutting-edge Generative AI solutions for various industries. With more than 12 years of experience in AI, I have a passion for democratizing practical AI skills and empowering professionals to leverage AI to transform their business.

Previously, I managed IBM's Data Science and AI Elite, delivering complex AI implementations for hundreds of clients. 

I also led the product management of IBM Watson Studio and Watson Machine Learning, an AI platform used by hundreds of customers and SaaS apps powered by AI. I hold a Master of Science in Telecommunications from Universitat Politècnica de Catalunya and speak three languages: Spanish, Catalan, French, and English.

Connect with me!

✉️ JOIN MY NEWSLETTER: Every Saturday morning, you'll get 1 actionable tip to launch and grow your AI strategies in business in less than 4 minutes. → GO HERE: https://www.nocode.ai/

📧 Email: armand@nocode.ai
X: @armand_ruiz


"It is kind of fun to do the impossible"
All opinions are my own and don't represent my employer.

Called it. 🎯 The Model Context Protocol (MCP) is officially moving to the Linux Foundation under the new Agentic AI Foundation.

I’ve been saying for a while that open governance is the only viable path forward for AI infrastructure. Today’s news proves it.

This brings Anthropic, OpenAI, Microsoft, Google, and others under one neutral banner. 

10,000+ active servers. 
97M+ SDK downloads. 
Zero vendor lock-in.

If you want an ecosystem to flourish, you have to open it up. The era of Agentic AI just got a serious upgrade.

Read the news here: https://lnkd.in/g7vy5-x2

At NeurIPS2025, Google presented Titans, a new architecture that combines the speed of RNNs with the performance of Transformers. 

The trade-off between infinite context and computational cost is the biggest hurdle in AI right now.

While Transformers are accurate but expensive to scale, and linear models are fast but lose detail, Titans delivers the best of both worlds by introducing Test-Time Memorization.

The Core Innovation: Instead of a static state, Titans uses a deep neural memory module that actively updates while running, utilizing a "Surprise Metric":
- Low Surprise: Routine data is processed efficiently without clogging memory.
- High Surprise: Anomalies and key details are instantly integrated into long-term memory.

The Results:
- Scales effectively to 2M+ token context windows.
- Outperforms larger models (including GPT-4) on extreme long-context reasoning benchmarks.
- Generalizes beyond text to genomics and time-series.

This is a move from passive processing to active, efficient learning.

Jensen just dropped a masterclass on the future of AI. 

It was great to hear from him in a long-format podcast conversation. 

Three key insights he shared:

1/ Human language is the new syntax: The "tech divide" is closing. You won't need C++ to code the future; you just need to speak.

2/ The "30-Day" Mindset: Nvidia operates like they are always 30 days from bankruptcy. This paranoia fuels their innovation and resilience.

3/ Safety is an engineering problem: Forget the sci-fi movie plots. AI safety is just like cybersecurity—as capabilities rise, so do the guardrails.

Pic taken during my epic commute

JSESSIONID

li_at

Talks about #ai, #nocode, #deeplearning, #machinelearning, and #artificialintelligence

building AI systems

Current mood: "Joining a new company is akin to an organ transplant - and you're the new organ. If you're not thoughtful in adapting to the new situation, you could end up being attacked by the organizational immune system and rejected."

Learning fast, exploring the culture, and pushing myself to bring out the best work I’ve ever done. 

Loving the challenge. 🤩

Gemini 3 is here and it isn’t just another model release. It’s Google firing on every AI cylinder: infra, research, product, and distribution.

A few things stand out:

1.	Full-stack advantage, finally realized.
Gemini 3 is the first model shipped into Google Search on day one. That’s not just marketing ; it’s how you put frontier AI in front of billions.

2.	The agent era is no longer theoretical.
With Deep Think mode, long context, multimodal understanding, and real-time planning, Gemini 3 moves beyond chat. It’s not a chatbot. It’s a problem-solver.

3.	AI is getting better at “reading the room.”
It reflects a core shift: models are starting to grasp intent and nuance and not just data.

Benchmarks back it up: topping LMArena, solving “Humanity’s Last Exam”, setting a new bar in math and science tasks. But that’s the sideshow.

More info here: https://lnkd.in/gWeXGwhC

I cannot wait to try it out

As a leader, your job is to run a tight ship.

That doesn’t mean control. It means precision.

Clear goals. 
Clear roles. 
Clear standards.

In fast-moving teams, especially in AI, ambiguity is expensive and confusion kills momentum.  Alignment compounds it.

Scaling laws in AI are nowhere near finished. The latest Gemini 3 results show it clearly.

Pre-training: Many believed progress had plateaued. Yet the jump from 2.5 to 3.0 is one of the biggest leaps we have seen. When you improve data, architecture, and compute together, you keep breaking ceilings. No walls in sight.

Post-training: This might be the real frontier. We are still early in how we align, steer, and specialize models. The innovation curve here is just beginning, and the gains on 3.0 prove it.

Good insights from Deepmind engineers this week.

Better models are not coming slowly. They are coming faster.

Plan for continuous capability jumps, not incremental upgrades. The disruption curve is steepening.

𝗔𝗜 𝗪𝗼𝗿𝗹𝗱 𝗠𝗼𝗱𝗲𝗹𝘀 𝟭𝟬𝟭

Current AI is often described as a "statistical correlation machine." It predicts the next word or pixel based on patterns it has seen before. World Models represent a shift toward causal understanding—giving machines a way to simulate the future.

What is a World Model? Think of it as an internal flight simulator. Instead of just recognizing an environment, the AI builds a mental model of how that environment works. It uses this model to test hypotheses ("If I drop this glass, it will break") without needing to actually perform the action.

The "𝗟𝗮𝘂𝗻𝗱𝗿𝘆" Example Imagine training a robot to fold clothes.

- 𝗪𝗶𝘁𝗵𝗼𝘂𝘁 𝗮 𝗪𝗼𝗿𝗹𝗱 𝗠𝗼𝗱𝗲𝗹: The robot must physically interact with the clothes millions of times, learning through endless trial and error.

- 𝗪𝗶𝘁𝗵 𝗮 𝗪𝗼𝗿𝗹𝗱 𝗠𝗼𝗱𝗲𝗹: The robot simulates the physics of the fabric in its head. It plans the fold internally, predicts the outcome, and only moves its arm when it is confident. This results in safer, faster, and more generalizable learning.

𝗛𝗼𝘄 𝘁𝗵𝗶𝘀 𝗱𝗶𝗳𝗳𝗲𝗿𝘀 𝗳𝗿𝗼𝗺 𝗰𝘂𝗿𝗿𝗲𝗻𝘁 𝗟𝗟𝗠𝘀: While Large Language Models (LLMs) are masters of syntax and semantics, they often struggle with physical causality. World Models differ because:

𝟭. 𝗧𝗵𝗲𝘆 𝘀𝗶𝗺𝘂𝗹𝗮𝘁𝗲, 𝗻𝗼𝘁 𝗷𝘂𝘀𝘁 𝗿𝗲𝗰𝗮𝗹𝗹: They don't just retrieve information; they run mental experiments.

𝟮. 𝗧𝗵𝗲𝘆 𝗹𝗲𝗮𝗿𝗻 𝗹𝗮𝘄𝘀, 𝗻𝗼𝘁 𝗷𝘂𝘀𝘁 𝗿𝘂𝗹𝗲𝘀: They infer the physics of their environment from data rather than being hand-coded.

𝟯. 𝗧𝗵𝗲𝘆 𝗮𝗿𝗲 𝗽𝗿𝗼𝗮𝗰𝘁𝗶𝘃𝗲: They predict "what happens next" in a state-space, not just a token-space.

𝗧𝗵𝗲 𝗥𝗼𝗮𝗱𝗺𝗮𝗽: The next frontier is the convergence of these technologies. By combining the reasoning of LLMs with the grounding of World Models, we move closer to Embodied Intelligence—software that can read, watch, plan, and act in the physical world.

it is very cool to work everyday with people in person. i think  product innovation and magic really happens with real human interaction

It’s insane how many hours I’ve seen senior technical leaders burn on architecture charts. 

All that time spent polishing pixels... now you just describe it in plain English and boom and nano banana AI handles the rest.

By the way, this is a solid, modern and agile AI stack. To build at x10 speed you need to have the right building blocks.

Fortusight, Founder | AI advisor | Ex-Dir of Llama @Meta & Ex-VP of Watson @IBM

Fortusight's AI stack

A lot of people ask me this question, I'll start with the absolute core:
1. I use Agno for multi-agent framework, they're fast, elegant and robust.
2. Exa for web grounding, I consider Exa a bigger booster than LLM choice for my use case.
3. FMP for premium, clean, reliable financial data turned into tailored tools.

For LLMs, I use O3 for multi-agent orchestration and planning, GPT 4.1 for digesting web content and supporting my A1Facts flow; Flash2.5 for structured extraction and Gemini 3 pro for synthesizing investment thesis.

I constantly progress the choices of LLMs prioritizing quality over price.

For tools, I use Cursor with Opus 4.5 (recently replacing Gemini 2.5 pro); and Figma make - which I absolutely love.

For internal ops agents, (1) managing coverage requests (2) digesting user feedback (3) analyzing product analytics (4) writing my weekly newsletter -- all built with Agno and Gemini 3 pro.

Less exciting but just as critical :-) Streamlit for front end [being replaced with react], and Firebase for database/auth/analytics -- both choices have been really critical for prototyping rapidly with my users.

The "secret sauce" is secret (lol), but I will say solving factuality in evolving market dynamics is a significant effort, and using expert-system techniques and simulations augments LLMs where they are critically weak.

Happy to share more if you have any questions -- and obviously here's the link if you want to try it out (https://lnkd.in/g7eR86dr)

AI Evals Explainer

Generated with Nano Banana Pro

Introducing SAM 3D: Powerful 3D Reconstruction for Physical World Images

and it’s not your typical 3D reconstruction tool.

It does what previous models couldn’t:
- Reconstruct real-world objects and scenes from a single image.
- Handle occlusion, indirect views, and cluttered backgrounds.
- Estimate human pose and shape with surprising accuracy.

Why does this matter?
Because for the first time, we’re seeing 3D perception at the scale, quality, and accessibility of today’s 2D models.

The architecture behind SAM 3D borrows from LLMs: pre-training on synthetic data, followed by post-training on real-world images using a human-in-the-loop ranking engine. The result is a feedback loop that continuously improves both the data and the model.

The implications stretch far beyond creative media. Robotics. E-commerce. Sports medicine. Interactive avatars. You name it.

And the best part? 

It's fast. 
Real-time fast.

Meta’s already using SAM 3D to power a “View in Room” feature in Facebook Marketplace; turning static listings into immersive experiences.

The gap between virtual and physical is shrinking. SAM 3D is a serious leap forward.

Learn more:
- 𝗥𝗲𝗮𝗱 𝘁𝗵𝗲 𝗮𝗻𝗻𝗼𝘂𝗻𝗰𝗲𝗺𝗲𝗻𝘁 𝗯𝗹𝗼𝗴: https://lnkd.in/g8w6dvAB
- 𝗥𝗲𝗮𝗱 𝘁𝗵𝗲 𝗦𝗔𝗠 𝟯𝗗 𝗢𝗯𝗷𝗲𝗰𝘁𝘀 𝗥𝗲𝘀𝗲𝗮𝗿𝗰𝗵 𝗣𝗮𝗽𝗲𝗿: https://lnkd.in/gd_HQE9c
- 𝗥𝗲𝗮𝗱 𝘁𝗵𝗲 𝗦𝗔𝗠 𝟯𝗗 𝗕𝗼𝗱𝘆 𝗥𝗲𝘀𝗲𝗮𝗿𝗰𝗵 𝗣𝗮𝗽𝗲𝗿: https://lnkd.in/gp3p9jaf
- 𝗗𝗼𝘄𝗻𝗹𝗼𝗮𝗱 𝗦𝗔𝗠 𝟯𝗗 𝗢𝗯𝗷𝗲𝗰𝘁𝘀: https://lnkd.in/gfwmcKGK
- 𝗗𝗼𝘄𝗻𝗹𝗼𝗮𝗱 𝗦𝗔𝗠 𝟯𝗗 𝗕𝗼𝗱𝘆: https://lnkd.in/g9CPHEXJ
- 𝗘𝘅𝗽𝗹𝗼𝗿𝗲 𝘁𝗵𝗲 𝗣𝗹𝗮𝘆𝗴𝗿𝗼𝘂𝗻𝗱: https://lnkd.in/guSDTnU3

A sharp, modern AI tech stack for building a serious startup.

Fortusight from Shadi Copty lays out a blueprint that actually reflects where the industry is going:

multi-agent architectures, real-time grounding, premium data, and a diversified LLM strategy tuned to specific jobs rather than brand loyalty.

1/ Agno for agent frameworks.
2/ Exa for grounding.
3/  FMP for clean financial data.
4/ A portfolio of models (O3, GPT-4.1, Flash2.5, Gemini 3) each picked for its superpower.

Cursor + Opus 4.5, Figma Make, Firebase, and Streamlit/React for fast product loops.

And a layer of expert systems + simulation to fix factuality where LLMs keep failing.

This is the kind of stack that lets a small team punch far above its weight.

🚀

Open article: Financial Analysis App by fortusight.streamlit.app

🚨 Stop scrolling. The math on this is barely real.

Get a $799/mo institutional AI research platform for just $50/mo.

The catch: Only 10 spots open. 

RIAs & Fund Managers—this is a complete no-brainer. 👇

https://fortusight.ai/

I need your help 🙏

I'm looking for design partners for my baby startup that just got pre-seed funded.

If you know a wealth fund manager, a small RIA, a family office that wants to reduce their equity research costs from ~$75K to less than what they pay for starbucks coffee - share this link with them: https://fortusight.ai  

For 10 design partners, I'm giving away Fortusight for $50/month instead of $800/month for a year in exchange for feedback to help guide the product's development.

The beta with our users has been incredibly successful, with recurring usage of our equity deep dives.

This will propel the company forward, and one day I will find ways to repay your kindness - many thanks ❤️

DMs might get missed, for collabs write to me at: collab.shivanivirdi@gmail.com

Hello 👋

I’m a Software Engineer passionate about solving complex problems and creating innovative solutions that enhance user experiences.

Things I talk about on LinkedIn:
- Artificial Intelligence and LLMs
- Software Engineering and Clean Code
- Productivity Hacks and Career Growth
- Insights from Building LLM-Powered Products

📲 If this resonates with you, let’s connect!

---

🎯 I’m an experienced Software Engineer with a creative mindset and a knack for building impactful solutions. My journey spans working on full-stack development, delivering unique user-facing features, to backend engineering, tackling distributed systems that process large-scale data.

🚀 I thrive on creating value for users by crafting elegant solutions to challenging problems, leveraging cutting-edge technologies, and delivering seamless experiences. My passion lies in blending technical expertise with creativity to build products that make a difference.

💻 Beyond coding, I’m dedicated to sharing practical insights to empower engineers, foster productivity, and drive growth, both in careers and life.

🌍 I aim to use technology as a force for positive change, building tools and systems that create meaningful impact.

🔍 If you’re looking to connect with someone who shares a passion for innovation, engineering excellence, and personal growth, feel free to reach out.

📲 Let’s connect here on LinkedIn or explore more about my journey through my posts!

Shivani Virdi

I taught myself AI engineering as a software engineer, and it's the best career move. Here's how I'd do it all over again.

Just the path that builds real skill, fast.
Here’s exactly where I’d start (and how I’d go deep):

𝗦𝘁𝗲𝗽 𝟬: Prerequisites You Can’t Skip
Build the intuition that’ll serve you forever.

→ Deep Learning Specialisation by Andrew Ng https://lnkd.in/gwqSPS4J

→ “Deep Learning” by Ian Goodfellow et al https://lnkd.in/grDi7rWE

𝗦𝘁𝗲𝗽 𝟭: Understand LLMs First — Before You Build
Most people skip this. Don’t.

→ Intro for busy users: https://lnkd.in/gg-NYzPe (Karpathy)

→ Deep dive into LLMs: https://lnkd.in/gCbqG56i (Karpathy)

→ The Core Paper: “Attention Is All You Need” https://lnkd.in/gXUccydp

→ Stanford CS25: https://lnkd.in/gUzsiN_e

→ Or read my NeoSage breakdowns for faster intuition
Issue 1: https://lnkd.in/g2pXsyHn
Issue 2: https://lnkd.in/gPimp6mv

𝗦𝘁𝗲𝗽 𝟮: Learn Prompting Like a Developer, Not a Dabbler
Prompting is design thinking, not guesswork.

→ OpenAI Prompt Guide https://lnkd.in/gqjcPxcQ

→ Prompting Guide https://lnkd.in/ga7FuQRT

→ Mini-Course: https://lnkd.in/gHwMeZzp

𝗦𝘁𝗲𝗽 𝟯: Get Your Hands Dirty — Application Layer

→ Get started with RAG here: https://lnkd.in/gTkNFRAz

Build these:
→ Chatbot 
→ Fine-tune a model
→ Build a RAG pipeline from scratch
here https://lnkd.in/gbdiAkPD


𝗦𝘁𝗲𝗽 𝟰: Go Deeper — Think in Systems
This is where 95% stop. And where real engineers begin.

→ Frameworks: Learn LangChain, LangGraph, and how they shape workflows

→ Protocols:
• Model Context Protocol (Article to get started: https://lnkd.in/gfdJqGU4)
• Google’s A2A 
→ Agents: Learn about planning, memory, and inter-agent coordination. Resources: https://lnkd.in/gFfxtN-c

→ Evaluations: If you can’t measure it, you can’t improve it

𝗥𝗲𝘀𝗼𝘂𝗿𝗰𝗲𝘀 𝗜 𝗧𝗿𝘂𝘀𝘁 𝗳𝗼𝗿 𝗟𝗲𝗮𝗿𝗻𝗶𝗻𝗴
• Deeplearning . ai
• OpenAI Academy
• Google’s white papers on Agents
• Andrej Karpathy’s YouTube Channel
• Hugging Face
• The Neural Maze by Miguel— newsletter with hands-on projects
• The LLM Engineer's Handbook by Paul & Maxime

• NeoSage by Yours Truly: systems thinking & intuition-first AI engineering https://blog.neosage.io

If I had to start all over again?
I’d follow this and ignore everything else.
Save it. Share it. Restart here.

Did I miss your favourite resource? Add it in the comments! 

♻️ Repost to your network.

AI Engineering | Founder @ NeoSage | ex-Microsoft • AWS • Adobe | Teaching 70K+ How to Build Production-Grade GenAI Systems

Pavitra Gupta

Learn 𝘀𝘆𝘀𝘁𝗲𝗺 𝗱𝗲𝘀𝗶𝗴𝗻 before Agentic AI
Learn 𝗱𝗮𝘁𝗮𝗯𝗮𝘀𝗲𝘀 before RAG
Learn 𝗵𝗼𝘄 𝗔𝗣𝗜𝘀 𝘄𝗼𝗿𝗸 before MCP
Learn 𝗡𝗟𝗣 before prompt engineering
Learn 𝗱𝗮𝘁𝗮 𝗽𝗿𝗲𝗽𝗿𝗼𝗰𝗲𝘀𝘀𝗶𝗻𝗴 before fine-tuning
Learn 𝗰𝗹𝗮𝘀𝘀𝗶𝗰 𝗠𝗟 before LLMs
Learn 𝗺𝗮𝘁𝗵 before neural networks
Learn 𝘁𝗼 𝗰𝗼𝗱𝗲 before vibe coding products
Learn 𝗵𝗼𝘄 𝘁𝗵𝗶𝗻𝗴𝘀 𝗯𝗿𝗲𝗮𝗸 before trying to scale them

There’s too much noise in this field
Everyone’s gathering information
Everyone’s hoarding roadmaps
Everyone has an 𝘶𝘯𝘭𝘪𝘮𝘪𝘵𝘦𝘥 𝘦𝘯𝘤𝘺𝘤𝘭𝘰𝘱𝘦𝘥𝘪𝘢 in their pocket,

But the 𝘤𝘰𝘳𝘦 𝘴𝘬𝘪𝘭𝘭 𝘰𝘧 𝘤𝘳𝘦𝘢𝘵𝘪𝘰𝘯 is getting lost
The skill of connecting the dots
Of building systems that 𝘢𝘤𝘵𝘶𝘢𝘭𝘭𝘺 work
Of learning by doing, not just consuming

So stop

You want to learn AI the right way?
→ Pick one resource
→ Stop hoarding
→ Stick to it
→ Go hands-on

Don’t know where to start? 
Here’s where I started:
👉 https://lnkd.in/gwqSPS4J

That’s it. No hacks. No shortcuts.
Just the hard, slow, real way to get good

♻️ Reposting might help someone who's lost in the noise

AI Engineering | Founder of NeoSage | ex-Microsoft • AWS • Adobe | Teaching 70K+ How to Build Production-Grade GenAI Systems

This is the simplest and the most complete introduction to RAG that you'll ever find.
I wish I had this guide when I first started.

Modern LLMs are powerful, but they’re static.

They can’t access your internal docs, recent tickets, or product updates.

They don’t “look up” answers. 
They interpolate. 
And when they don’t know, 
They hallucinate.

Most real-world use cases aren’t about abstract language.
They’re about your data.
→ What’s our refund policy?
→ What did the customer say last week?
→ What’s the latest HR guideline?
So, how do you bridge that gap?

You don’t need to fine-tune. 
You don’t need to prompt harder.
You need 𝗥𝗲𝘁𝗿𝗶𝗲𝘃𝗮𝗹-𝗔𝘂𝗴𝗺𝗲𝗻𝘁𝗲𝗱 𝗚𝗲𝗻𝗲𝗿𝗮𝘁𝗶𝗼𝗻 (𝗥𝗔𝗚).

Here’s what this guide breaks down:
🔹 𝗪𝗵𝘆 𝘀𝘁𝗮𝘁𝗶𝗰 𝗟𝗟𝗠𝘀 𝗳𝗮𝗶𝗹 𝗶𝗻 𝗽𝗿𝗼𝗱𝘂𝗰𝘁𝗶𝗼𝗻
They don’t have access to real-time or proprietary data, and when left unaided, they hallucinate with confidence.

🔹 𝗪𝗵𝘆 𝗽𝗿𝗼𝗺𝗽𝘁𝗶𝗻𝗴 𝗮𝗻𝗱 𝗳𝗶𝗻𝗲-𝘁𝘂𝗻𝗶𝗻𝗴 𝗳𝗮𝗹𝗹 𝘀𝗵𝗼𝗿𝘁
Prompting only changes 𝘩𝘰𝘸 the model responds. Fine-tuning changes the weights—but it’s costly, brittle, and still static. Neither gives the model 𝘯𝘦𝘸 𝘬𝘯𝘰𝘸𝘭𝘦𝘥𝘨𝘦 in real-time.

🔹 𝗪𝗵𝗮𝘁 𝗥𝗔𝗚 𝗮𝗰𝘁𝘂𝗮𝗹𝗹𝘆 𝗶𝘀
RAG doesn’t modify the model; it modifies the input. 
It retrieves relevant context (docs, tickets, policies) and feeds it into the prompt at inference time.

No retraining. Just better answers, grounded in your own data.

🔹 𝗪𝗵𝗮𝘁 𝘁𝗵𝗲 𝗥𝗔𝗚 𝗹𝗼𝗼𝗽 𝗹𝗼𝗼𝗸𝘀 𝗹𝗶𝗸𝗲 𝗲𝗻𝗱-𝘁𝗼-𝗲𝗻𝗱
→ Embed the user query
→ Perform vector search
→ Retrieve top-k relevant chunks
→ Inject those chunks into the prompt
→ Let the LLM generate a grounded response

🔹 𝗪𝗵𝗲𝗿𝗲 𝗻𝗮𝗶𝘃𝗲 𝗥𝗔𝗚 𝘀𝘆𝘀𝘁𝗲𝗺𝘀 𝗳𝗮𝗶𝗹
• Bad chunking (splits mid-sentence, loses semantics)
• Embeddings that don’t reflect your domain
• Missing metadata filtering
• Model ignoring context
• Retrieval failures that sound fluent but mislead users

🔹 𝗪𝗵𝗮𝘁 𝗺𝗮𝗸𝗲𝘀 𝗥𝗔𝗚 𝗽𝗿𝗼𝗱𝘂𝗰𝘁𝗶𝗼𝗻-𝗿𝗲𝗮𝗱𝘆
✔ Hybrid retrieval (dense + sparse)
✔ Re-ranking with cross-encoders
✔ Semantic chunking + metadata tagging
✔ Feedback loops to improve retrieval over time
✔ Monitoring retrieval quality

🔹 𝗛𝗼𝘄 𝘁𝗼 𝗲𝘃𝗮𝗹𝘂𝗮𝘁𝗲 𝗮 𝗥𝗔𝗚 𝘀𝘆𝘀𝘁𝗲𝗺
Using the 𝗥𝗔𝗚 𝗧𝗿𝗶𝗮𝗱:
1. 𝘙𝘦𝘵𝘳𝘪𝘦𝘷𝘢𝘭 𝘘𝘶𝘢𝘭𝘪𝘵𝘺 – Did you fetch the right chunks?
2. 𝘍𝘢𝘪𝘵𝘩𝘧𝘶𝘭𝘯𝘦𝘴𝘴 – Did the model stick to the context?
3. 𝘈𝘯𝘴𝘸𝘦𝘳 𝘘𝘶𝘢𝘭𝘪𝘵𝘺 – Was the response complete, clear, and helpful?

If you’re building with LLMs, this is the system blueprint you’ll keep referring back to.

♻️ Repost to help your network upskill

—
🔗 Read the full breakdown here: https://lnkd.in/gTkNFRAz

𝗥𝗲𝘁𝗿𝗶𝗲𝘃𝗮𝗹-𝗔𝘂𝗴𝗺𝗲𝗻𝘁𝗲𝗱 𝗚𝗲𝗻𝗲𝗿𝗮𝘁𝗶𝗼𝗻

If I had to start my AI/ML journey from scratch as a software engineer, these are the repos I’d pick to learn from: 9 GitHub repositories that actually 𝘵𝘦𝘢𝘤𝘩 𝘺𝘰𝘶 𝘵𝘰 𝘣𝘶𝘪𝘭𝘥, not just learn.

📌 Start here, go deep, and skip the hype.

𝟭. 𝗞𝗮𝗿𝗽𝗮𝘁𝗵𝘆’𝘀 𝗡𝗲𝘂𝗿𝗮𝗹 𝗡𝗲𝘁𝘄𝗼𝗿𝗸𝘀: 𝗭𝗲𝗿𝗼 𝘁𝗼 𝗛𝗲𝗿𝗼
The single best beginner resource to understand neural nets, by building them from scratch.
https://lnkd.in/gZumxBZw

𝟮. 𝗦𝘁𝗮𝗿𝘁 𝗠𝗮𝗰𝗵𝗶𝗻𝗲 𝗟𝗲𝗮𝗿𝗻𝗶𝗻𝗴
An all-in-one beginner guide for ML with curated paths, practical projects, and regular updates.
https://lnkd.in/ga_s6PUg

𝟯. 𝗠𝗟 𝗳𝗼𝗿 𝗕𝗲𝗴𝗶𝗻𝗻𝗲𝗿𝘀 (𝗯𝘆 𝗠𝗶𝗰𝗿𝗼𝘀𝗼𝗳𝘁)
Hands-on introduction to core machine learning concepts through real-world projects and Jupyter Notebooks.
https://lnkd.in/gdpUzKfx

𝟰. 𝗔𝗜 𝗳𝗼𝗿 𝗕𝗲𝗴𝗶𝗻𝗻𝗲𝗿𝘀 (𝗯𝘆 𝗠𝗶𝗰𝗿𝗼𝘀𝗼𝗳𝘁)
12-week curriculum walking you through AI foundations like search, logic, probabilistic reasoning, and more.
https://lnkd.in/gWrnGQ7D

𝟱. 𝗚𝗲𝗻𝗲𝗿𝗮𝘁𝗶𝘃𝗲 𝗔𝗜 𝗳𝗼𝗿 𝗕𝗲𝗴𝗶𝗻𝗻𝗲𝗿𝘀 (𝗯𝘆 𝗠𝗶𝗰𝗿𝗼𝘀𝗼𝗳𝘁)
Want to understand LLMs and GenAI in 2025? This repo is your friendly intro to text generation, embeddings, and more.
https://lnkd.in/gSxUv3fJ

𝟲. 𝗳𝗮𝘀𝘁𝗮𝗶
Built on top of PyTorch, fastai is both a library and a course for rapidly prototyping ML models without losing interpretability.
https://lnkd.in/gvVqbnGa

𝟳. 𝗔𝘄𝗲𝘀𝗼𝗺𝗲 𝗗𝗮𝘁𝗮 𝗦𝗰𝗶𝗲𝗻𝗰𝗲
A massive collection of the best free books, courses, tools, and datasets for anyone entering the data+AI world.
https://lnkd.in/gW7pBqAQ

𝟴. 𝗞𝗮𝗿𝗽𝗮𝘁𝗵𝘆’𝘀 𝗻𝗮𝗻𝗼𝗚𝗣𝗧
Want to train your own GPT from scratch? This repo walks you through a compact GPT implementation in pure PyTorch.
https://lnkd.in/gwPzqn-A

𝟵. 𝗟𝗮𝗻𝗴𝗖𝗵𝗮𝗶𝗻
As you progress into applications, LangChain is your gateway to building real-world LLM-powered tools and agents.
https://lnkd.in/gc6iqNzJ

This isn’t just a resource dump.
It’s the roadmap I’d give to any beginner trying to break into AI today.

Did I miss your favourite github repo? 
Add it in the comments to help others.

Save it. 
Repost it. 
Enjoy it.

---
If you're an AI builder, you'd love NeoSage.
Join 8000+ readers here → https://blog.neosage.io

I recently got promoted at Microsoft. 

And then I quit...
 
Let me explain.
 
The last 2 years at Microsoft were the fastest growth arc of my life.

I went from learning how Windows OS–level cryptography works (hardware and software) to shaping an entire new line of secure secrets-management capabilities on top of a legacy system.
 
There’s a 𝘷𝘦𝘳𝘺 specific type of high that comes from building something no one has done before.
 
No StackOverflow thread.
No internal docs.
No GPT that has any clue.
 
And then there’s the feeling of single-handedly solving an issue so niche it became a head-scratcher even for principal engineers (let me brag for a second, I solved it 😅).
 
I lived for that feeling.
 Which is why leaving was… bittersweet.
 
But while all of this was happening, something else was happening too.
 
Outside of work, I was upskilling like my life depended on it.
 
I fell deep into AI engineering the kind that isn’t hype or theory, but actual systems work.
 
And I realised how little 𝘵𝘳𝘶𝘭𝘺 𝘨𝘰𝘰𝘥, 𝘥𝘦𝘦𝘱𝘭𝘺 𝘦𝘯𝘨𝘪𝘯𝘦𝘦𝘳𝘦𝘥 documentation existed on the 𝗛𝗢𝗪 of AI systems.
 
It was to remediate this that I started my newsletter NeoSage .
 
I wrote, I experimented, I broke things, I rebuilt them.
 
And somehow, this outside learning began shaping my work at Microsoft too.
 
I was asked to deliver a hands-on RAG workshop for my org (it went incredibly well, and it contributed to my promotion).
 
Sister teams started reaching out for help on tough AI problems.
 
And suddenly, I had the rare privilege of choosing what problems I wanted to solve and how.
 
Building in public changed my career from the inside out.
 
So why did I leave?
 
Because at some point, doing everything solo while working full-time meant I was being pulled in every direction except the one that mattered most.
 
The lack of high-quality AI systems engineering knowledge isn’t just an annoyance, it’s a bottleneck for an entire industry.
 
And I couldn't shake the feeling that I 𝘯𝘦𝘦𝘥𝘦𝘥 to work on this.
 Properly.
 Fully.
 Without splitting myself between two worlds.
 
So a little over a month ago, I took the leap.
 
I quit.
 
Over the past few weeks, I’ve been building something I desperately wish existed when I was upskilling.
 
It’s bigger than anything I’ve done so far, and I’ll be sharing it with you soon.
 
This has been scary and exhilarating in equal measure.
 But I’ve never been more sure of anything.
 
If you’ve been here through my journey, thank you.
 And there’s a lot more on the way.
 
We’re going all in.

You can take away all my LLM subscriptions,  

But I’m not giving up ...
Claude Code.
 
Yup, it’s 𝘵𝘩𝘢𝘵 good.
 
Once you learn how to actually use it (and yes, there’s a curve),  
That 100x productivity everyone talks about?  
It’s real.
 
And no, I don’t switch off my brain when I use it.  
Quite the opposite.  
I stay in the driver’s seat the entire time.
 
Here’s exactly how I work with it:
 
↳ I design the system components myself
↳ I brainstorm the low-level details with it
↳ I never hand over full control (no “yes to all”)
↳ I read the docs first, then tell it what to look for (don’t let it roam free)
↳ I create dedicated development-progress docs in each phase to keep things accurate
↳ I set myself up for iteration: I review and test every sub-feature like I would a PR
↳ For the bugs it can’t solve: I research properly and 𝘨𝘶𝘪𝘥𝘦 𝘪𝘵 𝘰𝘯 𝘩𝘰𝘸 𝘵𝘰 𝘵𝘩𝘪𝘯𝘬
↳ I am extremely verbose with Claude
↳ I never offload the thinking, only the typing 
(It’s my intelligent typist, not my brain replacement)
 
And with this workflow, I’ve been able to build something genuinely 𝘦𝘯𝘨𝘪𝘯𝘦𝘦𝘳𝘪𝘯𝘨-𝘨𝘳𝘢𝘥𝘦 in a fraction of the time it would’ve otherwise taken.
 
(Spoiler: it still took me two months, because building for production doesn’t magically become a “weekend project,” even with all the AI in the world.)

How do you use AI-assisted coding?

If I had to explain how true AI reasoning works in 90 seconds, I'd show you the DeepSeek-R1 playbook. Here's the exact 4-stage process they used to make a model 𝘥𝘪𝘴𝘤𝘰𝘷𝘦𝘳 logic.

AI reasoning is the hottest topic right now. 
But only a few deeply understand it
This guide teaches you how AI learns to reason

Standard models are trained to imitate reasoning, not to think. 
They copy examples. But struggle when patterns break.

DeepSeek-R1 flipped the script. 
It wasn’t taught reasoning. 
It was incentivised to discover it.

Part 1: The Core Idea — Incentives > Instructions

DeepSeek-R1 learned to reason with no human-written examples.

The standard Way (Supervised):
• Feed “correct” answers
• Model copies the format
• Limited by example quality

The 'DeepSeek R1 Zero' Way (Incentivised):
• The model generates multiple answers
• Rewarded only when the output is correct (math solved, code runs)
• Used GRPO (Group Relative Policy Optimisation), no critic model
• Model learned that step-by-step reasoning increases reward

Part 2: The 4-Stage Playbook

Turning a raw reasoner into an aligned system, one fix at a time:

Stage 1: Fixing the Mess 
Problem: Messy, verbose, mixed-language output 
Fix: Small fine-tuning pass to enforce structure & language consistency

Stage 2: Deepening Reasoning 
Problem: Logic was shallow, mixing persisted 
Fix: RL pass rewarding both accuracy and clean output

Stage 3: Broadening Skills 
Problem: STEM-strong, but couldn’t chat, write, summarise 
Fix: Fine-tuned on 800K examples (600K reasoning, 200K general tasks)

Stage 4: Aligning Behaviour 
Problem: Still unhelpful or unsafe in open-ended prompts 
Fix: Final RL round using reward models for tone, helpfulness, safety

Part 3: The Payoff — Distilling Genius
They used the final dataset (~800K samples) to fine-tune smaller models like Llama3 and Qwen2.5.
No RL needed. Just outputs → supervision → transfer of reasoning ability.

Key Takeaway: Reasoning is emergent. It cannot be taught through imitation alone. It needs a systematic approach to build reasoning in layers

Each stage debugged the last and built one of the strongest open reasoning models yet.

Want the full architecture + training breakdown? 
Read the full issue (Link in the comment and the PDF)

♻️ Reposting this helps everyone in your network build deep intuition

Engineering @ Microsoft | Building GenAI Systems | Creator of NeoSage | 70K+ Learn AI Engineering with Me

How AI Learns to Reason: DeepSeek-R1 Case Study

If I had to bet on one skill in AI as an engineer…
I'd go for RAG. And these are the resources I'd pick first to self-learn this in 2026.

Why RAG?
Context windows are getting bigger.

You might think: "Why not just upload my entire doc DB to the chat?"

But that's flawed for two reasons:

1. Bigger context ≠ better context
Just because the model can see more doesn't mean it sees what matters.

2. Tokens aren't free
Serving millions of users with token-heavy prompts?

That'll burn a hole through your API budget.
You can't brute-force context.

You need to engineer it.

That's where RAG becomes non-negotiable.

Here's the roadmap I'd follow:

1 paper – the OG
https://lnkd.in/gp7y4zFu

1 blog – RAG in plain English
https://lnkd.in/gTkNFRAz

1 hands-on tutorial – get your hands dirty
https://lnkd.in/gneRRxg9

1 GitHub repo – by Nir Diamant
https://lnkd.in/gA7maM5Y

1 framework tutorial – LangChain's RAG guide
https://lnkd.in/g_U6GtqG

1 course list – curated by DeepLearning.ai
https://lnkd.in/gPQMJVF9

1 newsletter – weekly breakdowns + AI systems thinking
NeoSage → https://blog.neosage.io

---
𝗪𝗮𝗻𝘁 𝘁𝗼 𝗴𝗲𝘁 𝗵𝗮𝗻𝗱𝘀-𝗼𝗻 𝗯𝘂𝘁 𝗱𝗼𝗻'𝘁 𝗸𝗻𝗼𝘄 𝘄𝗵𝗮𝘁 𝘀𝘁𝗮𝗰𝗸 𝘁𝗼 𝗽𝗶𝗰𝗸?

Here's a free, no-frills stack:
↳ Haystack – pipeline design
↳ Qdrant – vector database
↳ FastEmbed – local embedding models
↳ Gemini API – generation
↳ Opik – observability
↳ DeepEval – evals

No decision paralysis. Just build.
---

Save this. Share it. Build systems that don't hallucinate for no reason.

Know a great RAG resource I missed?
Drop it below.

♻️ Reposting this helps everyone in your network upskill

---
P.S. If you want to go from zero LLM knowledge to fully optimized, deployed RAG, I'm building something for you. 

Announcement dropping soon. 
Follow + 🔔 to catch it.

I wasted months trying to understand “how LLMs actually work” by jumping between papers, blogs, and half-baked diagrams.
 
Terrible way to learn.
 
Too theoretical. Too fragmented. No intuition.
 
Then I watched Andrej Karpathy’s 𝘋𝘦𝘦𝘱 𝘋𝘪𝘷𝘦 𝘪𝘯𝘵𝘰 𝘓𝘓𝘔𝘴 𝘭𝘪𝘬𝘦 𝘊𝘩𝘢𝘵𝘎𝘗𝘛.
 
This lecture gives a clearer mental model of LLMs than most full courses.
 
Here’s why it’s different:
 
↳ It shows the real progression: 𝗯𝗮𝘀𝗲 𝗺𝗼𝗱𝗲𝗹 → 𝗮𝘀𝘀𝗶𝘀𝘁𝗮𝗻𝘁 → 𝗿𝗲𝗮𝘀𝗼𝗻𝗲𝗿.
 
↳ Makes the 𝗱𝗮𝘁𝗮 𝗽𝗶𝗽𝗲𝗹𝗶𝗻𝗲 concrete: filters, PII removal, dedup.
 
↳ Frames 𝘁𝗼𝗸𝗲𝗻𝗶𝘇𝗮𝘁𝗶𝗼𝗻 + 𝗰𝗼𝗻𝘁𝗲𝘅𝘁 as the core architectural limits.
 
↳ Separates 𝗸𝗻𝗼𝘄𝗹𝗲𝗱𝗴𝗲, 𝗯𝗲𝗵𝗮𝘃𝗶𝗼𝘂𝗿, 𝗿𝗲𝗮𝘀𝗼𝗻𝗶𝗻𝗴 cleanly.
 
↳ Exposes the model’s 𝗳𝗮𝗶𝗹𝘂𝗿𝗲 𝗺𝗼𝗱𝗲𝘀: hallucinations, gaps, refusals, and why tool use matters.
 
The kicker?
 
It gives more usable intuition than weeks of fragmented reading.
 
𝗧𝗼𝗽𝗶𝗰𝘀 𝘁𝗵𝗮𝘁 𝗮𝗰𝘁𝘂𝗮𝗹𝗹𝘆 𝗺𝗮𝘁𝘁𝗲𝗿 𝗳𝗼𝗿 𝗯𝘂𝗶𝗹𝗱𝗲𝗿𝘀:
 
• The 𝗣𝗿𝗲-𝘁𝗿𝗮𝗶𝗻𝗶𝗻𝗴 → 𝗦𝗙𝗧 → 𝗥𝗟/𝗥𝗟𝗛𝗙 stack and what each stage really adds.
• How 𝗱𝗮𝘁𝗮 𝗰𝘂𝗿𝗮𝘁𝗶𝗼𝗻 defines the entire parametric knowledge base.
• Why 𝘁𝗼𝗸𝗲𝗻𝗶𝘇𝗮𝘁𝗶𝗼𝗻 + 𝗰𝗼𝗻𝘁𝗲𝘅𝘁 𝘄𝗶𝗻𝗱𝗼𝘄 shape compression and reasoning depth.
• 𝗪𝗲𝗶𝗴𝗵𝘁𝘀 𝗮𝘀 𝗹𝗼𝘀𝘀𝘆 𝗺𝗲𝗺𝗼𝗿𝘆, 𝗰𝗼𝗻𝘁𝗲𝘅𝘁 𝗮𝘀 𝘄𝗼𝗿𝗸𝗶𝗻𝗴 𝗺𝗲𝗺𝗼𝗿𝘆, and why retrieval + tools outperform raw parameters.
• Hallucination as a 𝘁𝗿𝗮𝗶𝗻𝗶𝗻𝗴 𝗮𝗿𝘁𝗶𝗳𝗮𝗰𝘁, mitigated by self-knowledge probes and tool execution.
• Models need “𝘁𝗼𝗸𝗲𝗻𝘀 𝘁𝗼 𝘁𝗵𝗶𝗻𝗸”: multi-step reasoning isn’t optional.
• The 𝗦𝘄𝗶𝘀𝘀-𝗰𝗵𝗲𝗲𝘀𝗲 𝗰𝗮𝗽𝗮𝗯𝗶𝗹𝗶𝘁𝘆 𝗽𝗿𝗼𝗳𝗶𝗹𝗲: superhuman patches next to sharp failures.
 
Most people chase paper summaries and parameter-count hype.
 
Real intuition, the kind that lets you 𝗲𝗻𝗴𝗶𝗻𝗲𝗲𝗿 𝘀𝘆𝘀𝘁𝗲𝗺𝘀, not slides, comes from understanding this lifecycle.
 
Full lecture:
https://lnkd.in/gWHmWPtN 

♻️ Repost to help someone escape “random AI paper rabbit holes”.

The hardest part of building a production-grade RAG system isn’t retrieval. Isn’t generation.

It’s evaluation.

I’ve spent the last few months trying every stack under the sun to find something reliable, automated, and scalable, and here’s what everyone must understand:

Most RAG failures happen 𝘣𝘦𝘧𝘰𝘳𝘦 generation ever starts.
Because the real battle is the retrieval layer.

The metrics that truly decide whether your RAG works are:
Precision@k
Recall@k
MRR@k
NDCG@k

Answer relevance and faithfulness matter too, but they’re downstream.
They depend on your model, prompt, and what context you give it.

The hardest to tune is: retrieved context.

Let me break down what actually happens when you evaluate a RAG system.

1. The gold standard is still human evaluation
You look at:
↳ The question
↳ The answer
↳ The top-k retrieved chunks

And you judge:
• Are the chunks relevant?
• At what rank does the most relevant chunk appear?
• How much noise did the retriever pull in?
• Is the retrieved context 𝘤𝘰𝘮𝘱𝘭𝘦𝘵𝘦 𝘦𝘯𝘰𝘶𝘨𝘩 to answer the question?

The problem?
This requires a subject-matter expert.
It doesn’t scale across 100 questions, 20 iterations, or rapid experimentation.

So you automate it.
And this is where the fun ends.

2. Automation requires ground truth, and that’s its own nightmare
To evaluate retrieval, you need triples (question → expected answer → ground truth chunks).
Without ground truth, most metrics don’t even mean anything.

Synthetic test-set creation sounds great on paper: RAGAS, DeepEval, etc.
But depending on your domain, they may give you something:
• too generic
• too easy
• too harsh
• or completely unusable
Most of the time, you still end up hand-curating.

3. LLM-as-a-judge
The quality of your evaluation depends heavily on the model you pick.

↳ Some models can’t follow strict evaluation instructions 
↳ “Thinking models” do better, but cost more 
↳ LLMs can be too lax in one-shot scoring 
↳ Stricter control turns evaluation into a long-horizon pipeline

Once you force them to parse → compare → justify → score → verify, you’ve built an orchestration layer just to keep your judge honest.

In the end, LLM-based evaluation becomes another system you have to design, monitor, and pay for.

4. Semantic similarity metrics are stable, but dangerously rigid

The good part:
• deterministic
• repeatable
• cheap
• no hallucinated scoring
• perfectly consistent across runs

But here’s the real tradeoff:

↳ Semantic similarity only rewards matching the ground truth, not correctness
↳ If your ground truth is narrow, your system will look worse as it improves
↳ You lose the nuance that LLM judges provide

Evaluating RAG is hard.
You’re balancing:
• human judgment
• automated scoring
• ground truth creation
• retrieval tuning
• non-determinism across the pipeline

And it takes multiple cycles before you find a setup that actually reflects reality.

How do you evaluate your RAG?

♻️ Repost to share these insights.

If I could suggest one product as a masterclass in what context engineering can achieve... 

It would be Zerve.

Let me break down why.

Say you're doing exploratory data analysis on a new dataset.

Your workflow looks something like this:

1. Load the data, check shape and dtypes
2. Look at missing values: which columns, what percentage
3. Check distributions:  are there outliers? skewed features?
4. Look at correlations between variables
5. Visualize relationships with the target
6. Decide which features to keep, which to transform, which to drop

As a human, by step 5, you're holding a lot in your head:

↳ That 'income' has 12% nulls but 'age' is complete
↳ That 'transaction_amount' is heavily right-skewed (needs log transform)
↳ That 'region' has 47 unique values (probably needs grouping)
↳ That 'signup_date' and 'first_purchase' are highly correlated (keep one)
↳ The visualizations you made that informed these decisions

Now here's what Cursor sees:
↳ The files you're currently writing
↳ The other code files in your repo
↳ Not the actual outputs, the charts, the .describe() tables, the correlation matrix

It doesn't know that 'income' has nulls.
It can't see the histogram that showed the skew.
It doesn't know which features you've already decided to drop.

So when you ask "which features should I transform?" 
it's guessing based on code, not results.

This is the orchestration gap.
It's not about whether AI can execute code.
It's about whether AI can see your workflow as a connected system

I've been exploring what it looks like when context is actually built into the architecture.

Zerve is the clearest implementation I've found.

Here's how they structure it across 5 layers:

𝟭. 𝗖𝗼𝗱𝗲 𝗖𝗼𝗻𝘁𝗲𝘅𝘁
The agent sees all your code blocks, not just the one you're editing. 
It understands dependencies between them.

𝟮. 𝗗𝗮𝘁𝗮 𝗖𝗼𝗻𝘁𝗲𝘅𝘁
It connects to your actual data sources. 
Sees the schema, column types, row counts, sample values. 

𝟯. 𝗘𝘅𝗲𝗰𝘂𝘁𝗶𝗼𝗻 𝗖𝗼𝗻𝘁𝗲𝘅𝘁
Each block runs in real compute (Lambda, Fargate, GPU). 
The agent sees actual outputs, DataFrames, charts, error traces

𝟰. 𝗪𝗼𝗿𝗸𝗳𝗹𝗼𝘄 𝗖𝗼𝗻𝘁𝗲𝘅𝘁 (𝗗𝗔𝗚)
Your pipeline is a directed graph. 
Block A feeds Block B feeds Block C. 
The agent understands this structure, state flows forward, dependencies are explicit.

𝟱. 𝗙𝗲𝗲𝗱𝗯𝗮𝗰𝗸 𝗖𝗼𝗻𝘁𝗲𝘅𝘁
When code fails, the agent sees the real error in context. 
It tries a different approach automatically. 
Learnings carry forward, no manual copy-paste loop.

The key insight: it's not any single layer.
It's that all 5 are unified.

When you ask, "which features need transformation?" 

It gives recommendations based on actual results because it has the same context you do.

If you want to see this in action: https://lnkd.in/gPc6B6eb

♻️ Repost to share this with your network

The 5 layers of Context AI Agents Need

AI systems that scale aren't MCP. 
AI systems that scale aren't agents. 
AI systems that scale aren't LLM APIs. 
AI systems that scale aren't vector DBs. 
AI systems that scale aren't prompt engineering.
 
AI systems that scale need to manage the CAL triangle.
 
𝗠𝗼𝘀𝘁 𝗽𝗿𝗼𝗱𝘂𝗰𝘁𝗶𝗼𝗻 𝗟𝗟𝗠 𝘀𝘆𝘀𝘁𝗲𝗺𝘀 𝗺𝗮𝗸𝗲 𝘁𝗵𝗲 𝘀𝗮𝗺𝗲 𝗺𝗶𝘀𝘁𝗮𝗸𝗲:
 
They try to optimize cost, accuracy, and latency simultaneously.
You can't.
 
Every LLM system faces the CAL triangle: Cost, Accuracy, Latency.
 
Pick one to optimize heavily.
Get decent performance on another.
Sacrifice the third.
 
𝗢𝗽𝘁𝗶𝗺𝗶𝘇𝗲 𝗳𝗼𝗿 𝗖𝗢𝗦𝗧:
• Use smaller models (GPT-4o-mini at $0.15/1M vs o1 at $15/1M = 100x cheaper)
• Semantic caching (68% cache hit rate = skip LLM call entirely)
• You get: Fast latency (smaller models = faster inference)
• You sacrifice: Accuracy on edge cases (simple models miss nuance)
 
𝗢𝗽𝘁𝗶𝗺𝗶𝘇𝗲 𝗳𝗼𝗿 𝗔𝗖𝗖𝗨𝗥𝗔𝗖𝗬: 
• Best models (o1, Claude Opus) with multi-step verification
• Structured outputs, validation loops catch hallucinations
• You get: Acceptable cost at low volume (or selective routing)
• You sacrifice: Latency (o1 reasoning = 10-30 seconds)
 
𝗢𝗽𝘁𝗶𝗺𝗶𝘇𝗲 𝗳𝗼𝗿 𝗟𝗔𝗧𝗘𝗡𝗖𝗬:
• Speculative decoding (draft model proposes, verifier accepts in parallel = 2-3x speedup)
• Fast models (Gemini Flash 1.5) with aggressive prompt compression
• You get: Lower cost (shorter prompts = fewer tokens)
• You sacrifice: Accuracy (less reasoning time, compressed context)
 
𝗕𝘂𝘁 𝗵𝗲𝗿𝗲'𝘀 𝘄𝗵𝗮𝘁 𝗺𝗼𝘀𝘁 𝗽𝗲𝗼𝗽𝗹𝗲 𝗺𝗶𝘀𝘀:
You CAN escape the triangle.
 
The cost: 𝘂𝗽𝗳𝗿𝗼𝗻𝘁 𝗲𝗻𝗴𝗶𝗻𝗲𝗲𝗿𝗶𝗻𝗴 𝗲𝗳𝗳𝗼𝗿𝘁 + 𝗼𝗻𝗴𝗼𝗶𝗻𝗴 𝗺𝗮𝗶𝗻𝘁𝗲𝗻𝗮𝗻𝗰𝗲.
 
𝗛𝗼𝘄 𝘁𝗼 𝗴𝗲𝘁 𝗮𝗹𝗹 𝘁𝗵𝗿𝗲𝗲 (𝗮𝘁 𝘁𝗵𝗲 𝗲𝗻𝗴𝗶𝗻𝗲𝗲𝗿𝗶𝗻𝗴 𝗹𝗮𝘆𝗲𝗿):
 
Fine-tune small models to specific tasks:
↳ Accuracy of large models, cost of small models
↳ Trade-off: High-skill work, needs retraining as data drifts, model lock-in
 
Build a memory layer that keeps context precise:
↳ Clean context means fewer tokens for better accuracy = lower cost + faster
↳ Trade-off: Complex state management, hard to orchestrate, harder to debug
 
Smart caching that balances similarity thresholds:
↳ Contextual accuracy + speed + cost savings
↳ Trade-off: Cache invalidation strategy and threshold tuning need nuance
 
Orchestration routing:
↳ Simple queries → fast/cheap models
↳ Complex queries → slow/accurate models
↳ Trade-off: Classification logic, more moving parts
 
𝗧𝗵𝗲 𝗿𝗲𝗮𝗹 𝘁𝗿𝗮𝗱𝗲𝗼𝗳𝗳 𝗶𝘀𝗻'𝘁 𝗖𝗔𝗟.
 
𝗜𝘁'𝘀 𝗖𝗔𝗟 𝘃𝘀 𝗲𝗻𝗴𝗶𝗻𝗲𝗲𝗿𝗶𝗻𝗴 𝗲𝗳𝗳𝗼𝗿𝘁.
 
Most teams optimize at the model layer (easy, limited gains).
 
Production systems optimize at the orchestration layer (hard, unlimited gains).
 
Which layer are you optimizing at?

♻️ Repost this to help your network upskill

The first CS project I ever built took me 2 months. 
Yesterday, I rebuilt it in under 30 minutes.
 
10 years ago in Class 11, I wrote my first end-to-end program:
a terminal-based Snake game in C++.
 
No graphics engine.
One modularised Turbo C++ file running in DOS.
A 2D array printing symbols inside a 𝚠𝚑𝚒𝚕𝚎(!𝚐𝚊𝚖𝚎𝙾𝚟𝚎𝚛) loop.
 
The hardest part?
 
Building a persistent high-score system using file I/O and sorting, and feeling like an absolute brainiac for getting it right.
 
Yesterday, I rebuilt it again (as an ode to 10 years of honing the craft).
Same idea, completely different world.
 
This time, I ended up with a 𝗳𝘂𝗹𝗹 𝟯𝗗, 𝗺𝗼𝗱𝗲𝗿𝗻 𝗿𝗲𝗺𝗮𝗸𝗲, built entirely on Replit:
 
• a React (Vite) frontend
• a fully playable 3D Snake rendered using @𝚛𝚎𝚊𝚌𝚝-𝚝𝚑𝚛𝚎𝚎/𝚏𝚒𝚋𝚎𝚛 + @𝚛𝚎𝚊𝚌𝚝-𝚝𝚑𝚛𝚎𝚎/𝚍𝚛𝚎𝚒
• complete client-side game logic inside a TypeScript component
• smooth movement, lighting, and controls
• high scores stored locally in the browser
• multiple maze styles
• and a scaffolded Node.js backend with Express
 
All of this came together in under 30 minutes of vibe-coding with Replit AI:
describe → scaffold → refine → run → deploy.
 
It’s surreal to see the full arc of 10 years in one project.
 
From a no-graphics terminal loop → to a full-stack 3D web app…
and a completely new era of building software.

A lot has changed since.
 
PS: Please don’t judge my gameplay in the video 🥲 
(The obstacle maze is 𝘴𝘦𝘳𝘪𝘰𝘶𝘴𝘭𝘺 hard.)
 
I’ve published the app, and I want to see your scores 🙂
https://lnkd.in/gBppE3hA
 
And if you’ve got a fun idea or a serious one, you’ll love whipping it up on Replit.
Try it here for free:
https://lnkd.in/gc5K5qGa

If you want agents that actually ship, I’d start with these 12 principles of agentic AI system design and refuse to compromise on them:
 
1. Goal-first, outcome-driven  
↳ Start from explicit, measurable goals and encode them in prompts, schemas, and metrics.
↳ Keep objectives legible (mission owner, SLAs, KPIs) so every action maps to a business outcome.
 
2. Single-responsibility agents  
↳ Use many small, focused agents; each owns one capability or workflow slice.  
↳ Easier debugging, specialised prompts/tools, and clean agent replacement.
 
3. Plan–act–reflect loop  
↳ Make the loop explicit: perceive → plan → act → reflect → update.  
↳ Allow plan revision when signals change instead of blind forward motion.
 
4. Tools as APIs, not hacks  
↳ Treat tools (RAG, DB ops, APIs, human contact) as typed, structured interfaces.  
↳ Version tool contracts so tools and models evolve independently.
 
5. Own your control flow  
↳ Don’t bury orchestration inside prompts; use workflows or state machines.  
↳ LLM decides next step; your code enforces invariants and recovery.
 
6. Stateless reducer, explicit state  
↳ Keep LLM calls pure; push durable state into memory stores, DBs, or logs.  
↳ This enables retries, scaling, auditing, and avoids context-window drift.
 
7. Memory as a first-class subsystem  
↳ Separate short-term context, long-term knowledge, and interaction history.  
↳ Define strict read/write rules so memory stays meaningful and precise.
 
8. Multi-agent orchestration patterns  
↳ Choose a pattern (supervisor, adaptive network, custom orchestrator) and stick to it.  
↳ Standardise delegation, negotiation, and result merging to prevent agent sprawl.
 
9. Observability and traceability  
↳ Log prompts, plans, tool calls, errors, and outputs in structured formats.  
↳ Support trace replay and diffing to identify loops, tool spam, failures.
 
10. Safety, guardrails, and human-in-the-loop  
↳ Enforce auth, scoping, and policy at the orchestration layer—not just via prompts.  
↳ Provide escalation paths for approvals or handoff when confidence drops.
 
11. Robustness through idempotence and recovery  
↳ Make actions idempotent or compensatable so retries are safe.  
↳ Use timeouts, backoff, circuit breakers, and degraded-operation strategies.
 
12. Continuous evaluation and improvement  
↳ Track task-level and system-level metrics (success, latency, cost, overrides).  
↳ Use synthetic tests, canaries, and log replays to evolve prompts and tools safely.
 
Agentic AI isn’t “add more agents and hope something smart emerges.”
 
It’s disciplined system design with a stochastic core.
 
♻️ 𝗥𝗲𝗽𝗼𝘀𝘁 to help more engineers move beyond prompt chains to real systems.

I wish I had this guide when I first started learning the basics of NLP. The advice I got was to read "Attention is all you need." But...

As a beginner (and honestly even as you advance), that paper is a tough read.

Here's the intuitive evolution of sequence modelling that you actually need to understand, starting from the most fundamental building block:

1. The Perceptron
The foundational unit of a neural network. It computes a weighted sum of inputs and passes the result through an activation function.

► Limitation: It's static and stateless, meaning it has no memory of past inputs. Unsuitable for sequences on its own.

⬇️

2. Recurrent Neural Networks (RNNs)
The first architecture designed for sequences. 

It introduces a hidden state that acts as memory, combining the current input with the information from the previous state.

► Limitations: The sequential nature prevents parallel processing. Long-range dependencies are lost due to the vanishing gradient problem during backpropagation.

⬇️

3. The Attention Mechanism
A radical shift that overcomes RNN limitations. 

It gives the model a superpower: to directly measure the relationship between any two words in a sentence, no matter how far apart they are.

► How it works (without jargon, intuition only):

1. Calculate Relevance: For any word, the model calculates a "relevance score" to every other word in the sentence. A high score means the words are highly related for the current task.
   
2. Distribute Influence: These scores are converted into "influence weights." A word with a high score gets a bigger say in the meaning of the word being analyzed.
   
3. Blend Information: The model creates a new, context-rich version of the original word by blending information from all other words according to their influence weights. 
   
   This is how the model knows "it" refers to "the car" and not "the street" in the sentence "The car drove down the street until it ran out of gas.”
   
► Crucial Detail: Since this system looks at all words at once, Positional Embeddings (codes that signify word order) are added to the input to ensure the model doesn't lose the original sentence structure.

⬇️

4. The Transformer
An architecture built entirely on self-attention, completely replacing the recurrence of RNNs.

► The Result: Massive parallelisation, superior handling of long-range dependencies, and the scalability that powers modern Large Language Models (LLMs). The "T" in GPT literally stands for Transformer.

To dive deeper, I can't recommend these three videos enough:
1️⃣ Introduction to Transformers w/ Andrej Karpathy 
https://lnkd.in/gKZ7MKeZ

2️⃣ MIT 6.S191: RNNs, Transformers, and Attention
https://lnkd.in/gfSgxkGg

3️⃣ Attention Is All You Need by Yannic
https://lnkd.in/gewCufwP

Over to you: what's your favourite NLP learning resource?

♻️ Repost to share these insights.

Your finance team is still chasing receipts manually.
While this $1B ARR fintech is letting AI agents do that for 200,000+ businesses.
 
As I move from a 9–5 to building something of my own,
 
I’ve had to dive deep into how global payments 𝘢𝘤𝘵𝘶𝘢𝘭𝘭𝘺 work
 and it’s shocking how much money founders silently lose.
 
𝗣𝗹𝗲𝗮𝘀𝗲, 𝘀𝘁𝗼𝗽 𝗹𝗼𝘀𝗶𝗻𝗴 𝟯–𝟲% 𝗼𝗻 𝗲𝘃𝗲𝗿𝘆 𝗶𝗻𝘁𝗲𝗿𝗻𝗮𝘁𝗶𝗼𝗻𝗮𝗹 𝗽𝗮𝘆𝗺𝗲𝗻𝘁.
 
You don’t need multiple banks across multiple countries.
 
You need clarity of currency,
 precision of rails,
 and a loop of same-day settlement.
 
Most global businesses don’t fail because of bad products.
 
They fail because banks weren’t built for how business works today.
 
𝗧𝗵𝗮𝘁’𝘀 𝘄𝗵𝗲𝗿𝗲 𝗔𝗶𝗿𝘄𝗮𝗹𝗹𝗲𝘅 𝗰𝗼𝗺𝗲𝘀 𝗶𝗻.
 Used by McLaren Racing, Canva, Arsenal, and 200,000+ businesses.
 
𝗛𝗲𝗿𝗲’𝘀 𝘄𝗵𝘆 𝗳𝗼𝘂𝗻𝗱𝗲𝗿𝘀 𝗰𝗵𝗼𝗼𝘀𝗲 𝗶𝘁:
 
• 𝗠𝘂𝗹𝘁𝗶-𝗰𝘂𝗿𝗿𝗲𝗻𝗰𝘆 𝗮𝗰𝗰𝗼𝘂𝗻𝘁𝘀
 Hold 20+ currencies in one place. Convert only when 𝘺𝘰𝘶 decide.
 
• 𝗙𝗮𝘀𝘁𝗲𝗿 𝘁𝗵𝗮𝗻 𝗦𝗪𝗜𝗙𝗧
 90%+ of payments arrive the same day. No 3–5 day limbo.
 
• 𝟲𝟬-𝘀𝗲𝗰𝗼𝗻𝗱 𝗴𝗹𝗼𝗯𝗮𝗹 𝗮𝗰𝗰𝗼𝘂𝗻𝘁𝘀
 Opening accounts abroad used to take weeks.
 Airwallex does it instantly, from your laptop.
 
• 𝗧𝗿𝗮𝗻𝘀𝗽𝗮𝗿𝗲𝗻𝘁 𝗳𝗲𝗲𝘀
 They make money on transactions, not forced FX.
 Their incentives align with saving you money.
 
• 𝗔𝘂𝘁𝗼𝗺𝗮𝘁𝗶𝗼𝗻-𝗿𝗲𝗮𝗱𝘆
 They’re building AI agents to handle the repetitive work:
 collecting receipts, matching transactions, flagging policy exceptions.
 
• 𝗕𝘂𝗶𝗹𝘁 𝗳𝗼𝗿 𝘀𝗰𝗮𝗹𝗲
 $235B+ in payment volume.
 $1B ARR growing 90% YoY.
 
The old finance stack was built for a world that no longer exists.
 
If you’re building something global,
 𝘁𝗵𝗶𝘀 𝗶𝘀 𝘁𝗵𝗲 𝗶𝗻𝗳𝗿𝗮𝘀𝘁𝗿𝘂𝗰𝘁𝘂𝗿𝗲 𝘁𝗼 𝗹𝗼𝗼𝗸 𝗮𝘁.
 
Try it here: http://airwallex.com

If you didn’t catch AWS re:Invent this year, there’s a shift in their agentic AI strategy that you need to see.
Three major signals dropped:

1️⃣ 𝗡𝗲𝘄 𝗔𝗴𝗲𝗻𝘁𝗶𝗰 𝗔𝗜 𝗖𝗼𝗺𝗽𝗲𝘁𝗲𝗻𝗰𝘆 𝗰𝗮𝘁𝗲𝗴𝗼𝗿𝗶𝗲𝘀 
AWS is now officially recognising partners who can ship autonomous systems in 𝘱𝘳𝘰𝘥𝘶𝘤𝘵𝘪𝘰𝘯: across Applications, Tools, and Consulting Services. 

A few of the standout names on the list: 
Anthropic, Cohere, Databricks, LangChain, Snowflake, IBM, Deloitte, Accenture, TCS, Weights & Biases, MongoDB, Neo4j, Zilliz and many others. 

2️⃣ 𝗔𝗴𝗲𝗻𝘁 𝗠𝗼𝗱𝗲 𝗶𝗻 𝗔𝗪𝗦 𝗠𝗮𝗿𝗸𝗲𝘁𝗽𝗹𝗮𝗰𝗲  
Think of it as an AI layer that helps you 𝘳𝘦𝘢𝘴𝘰𝘯 through 30K+ solutions, instead of manually sifting through endless listings.

Discovery → comparison → shortlisting… done by an agent.

(And if you’re building tools, this should tell you where GTM is heading.)

3️⃣ 𝟮,𝟯𝟬𝟬+ 𝗮𝗴𝗲𝗻𝘁𝘀 𝗮𝗻𝗱 𝘁𝗼𝗼𝗹𝘀 𝗮𝗹𝗿𝗲𝗮𝗱𝘆 𝗹𝗶𝘃𝗲 𝗶𝗻 𝘁𝗵𝗲 𝗠𝗮𝗿𝗸𝗲𝘁𝗽𝗹𝗮𝗰𝗲 
Which means one thing: distribution is consolidating fast.
If you’re in the agentic ecosystem and you’re not thinking about Marketplace distribution, you’re already behind.

Why this matters:
 
• Customers working with AWS AI Competency Partners deploy ~𝟮𝟱% 𝗳𝗮𝘀𝘁𝗲𝗿.
• AWS has already put $𝟭𝟭𝟱𝗠+ behind the program.
• And the agentic AI tools market is projected to hit $𝟮𝟰.𝟰𝗕 𝗯𝘆 𝟮𝟬𝟯𝟬 with 𝟯𝟳% 𝗮𝗻𝗻𝘂𝗮𝗹 𝗴𝗿𝗼𝘄𝘁𝗵.
  
𝗕𝘂𝗶𝗹𝗱𝗲𝗿 𝗧𝗮𝗸𝗲𝗮𝘄𝗮𝘆

Most people will treat this as an “industry announcement.”

But here’s the real story:

→ 𝗧𝗵𝗲 𝗯𝘂𝘆𝗶𝗻𝗴 𝗷𝗼𝘂𝗿𝗻𝗲𝘆 𝗳𝗼𝗿 𝗔𝗜 𝘀𝘆𝘀𝘁𝗲𝗺𝘀 𝗶𝘀 𝗯𝗲𝗰𝗼𝗺𝗶𝗻𝗴 𝗮𝗴𝗲𝗻𝘁-𝗺𝗲𝗱𝗶𝗮𝘁𝗲𝗱.
If discovery itself is handled by an AI agent (Agent Mode), then:
⤷ your messaging needs to be machine-interpretable 
⤷ your positioning must be unambiguous 
⤷ your product metadata becomes part of your go-to-market strategy 

→ 𝗧𝗵𝗲 𝗱𝗲𝗳𝗶𝗻𝗶𝘁𝗶𝗼𝗻 𝗼𝗳 “𝗽𝗿𝗼𝗱𝘂𝗰𝘁𝗶𝗼𝗻-𝗴𝗿𝗮𝗱𝗲” 𝗮𝗴𝗲𝗻𝘁 𝘀𝘆𝘀𝘁𝗲𝗺𝘀 𝗶𝘀 𝗯𝗲𝗶𝗻𝗴 𝘀𝘁𝗮𝗻𝗱𝗮𝗿𝗱𝗶𝘇𝗲𝗱.
Competency partners now have to prove:
⤷ orchestration reliability 
⤷ guardrails + governance 
⤷ traceability 
⤷ enterprise-ready integration paths 
This raises the bar across the ecosystem

→ 𝗔𝗴𝗲𝗻𝘁 𝗲𝗰𝗼𝘀𝘆𝘀𝘁𝗲𝗺𝘀 𝘄𝗶𝗹𝗹 𝗰𝗼𝗻𝘀𝗼𝗹𝗶𝗱𝗮𝘁𝗲 𝗮𝗿𝗼𝘂𝗻𝗱 𝗰𝗹𝗼𝘂𝗱 𝗺𝗮𝗿𝗸𝗲𝘁𝗽𝗹𝗮𝗰𝗲𝘀.
The future of agent distribution looks a lot like the future of SaaS distribution: centralized, curated, compliance-first, and integrated into existing procurement workflows.

Check out the announcement here: 
https://lnkd.in/gyiQP_wb

#AgenticAI #AWS #AIAgents #AWSPartners

taplio

The Battle

Armand Ruiz

Shivani Virdi

Followers

Posts

Engagements

Likes

Performance ScoreArmand Ruiz's LinkedIn Performance

Performance ScoreShivani Virdi's LinkedIn Performance

Ready to grow your LinkedIn presence?

taplio

The Battle

Armand Ruiz

Shivani Virdi

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);}Armand Ruiz's LinkedIn Performance

Performance ScoreShivani Virdi's LinkedIn Performance

Ready to grow your LinkedIn presence?

Performance ScoreArmand Ruiz's LinkedIn Performance