Kabya Basu

MLOps/LLMops Engineer

[PyTorch @PyTorch]

https://t.co/pZKSCPtZfc..*

[Elon Musk @elonmusk]

Based on strong positive feedback from customers in our beta test program, @SpaceXAI will make Grok 4.5 available to the public tomorrow.

It is an Opus-class model, but faster, more token-efficient and lower cost.

[Roan @RohOnChain]

My friend applied to 200 tech jobs in two years. No PhD. No Stanford.

Last month Anthropic offered him $750,000.

I asked him how he broke in from zero.

He sent me a course that was never supposed to get out. A 3-hour video to build a full LLM from scratch.

A developer teaches you exactly how LLMs like ChatGPT and Claude are actually built.

I watched it last night.

Halfway through, I realized it's embarrassingly simple to break into an AI lab.

Bookmark this and read the article below.

• 00:00 - intro to LLMs
• 05:43 - LLM transformer architecture
• 40:24 - training the LLM
• 1:30:27 - modernizing the LLM
• 2:33:53 - scaling the LLM

[vLLM @vllm_project]

🎉 Congrats to the @MosiAI_Official team on MOSS-Transcribe-Diarize-0.9B, an open, end-to-end model for multi-speaker long-audio transcription, with day-0 support in vLLM.

Most setups chain ASR + diarization + alignment (WhisperX-style). This one does all three in a single generative pass. It transcribes the speech, tags who is speaking, and emits timestamps together:

[0.11][S01] Good morning![1.03]
[1.11][S02] Morning, guys![1.34]

A Whisper-style audio encoder feeds a Qwen3-style causal decoder, so a recording up to ~90 minutes goes in as one shot, no chunking or stitching. Keyword biasing lets you prime names, product codes, and domain terms so proper nouns come out right. Useful for meeting notes, interviews, call-center QA, and podcast transcription.

🔗 https://t.co/tTBqjY3vrL

[Movez @0xMovez]

Andrew Ng just dropped a 3-hour course on how to become an AI Engineer in 2026:

• 00:00 - How to build agentic AI systems
• 04:25 - Future of AI engineering
• 23:38 - AI Prompting full course
• 2:52:17 - Creating an app with AI in 30 minutes

This 3-hour watch could replace 10 AI engineering courses on the internet.

Watch it today, then read how to run a self-improving system in the article below.

[freeCodeCamp.org @freeCodeCamp]

Calculus is a powerful tool for understanding change, motion, and growth - and it's good to know as a dev.

In this College Calculus course, Ed teaches you the key concepts through the lens of Python.

You'll learn about limits, derivative rules, slope interpretation, various theorems, and how to apply symbolic math libraries like SymPy for graphing & computation.

https://t.co/KGvwu3EQwO

[Kabya Basu @kabyabasu]

@INCIndia This post shows exactly why many educated Indians don’t vote for Congress anymore

[Param @ParamSiddh]

Best YouTube Channels To Learn AI in 2026 (No BS)

1. Fundamentals – 3Blue1Brown
2. Deep Learning – Andrej Karpathy
3. AI Research – Yannic Kilcher
4. Practical AI – AssemblyAI
5. LLMs – AI Explained
6. ML Theory – StatQuest
7. Papers Simplified – Two Minute Papers
8. GenAI – Matthew Berman
9. AI Agents – Nicholas Renotte
10. Applied ML – Krish Naik
11. PyTorch – Aladdin Persson
12. Math for ML – Serrano Academy
13. Industry Insights – Lex Fridman
14. Real-world AI – DeepLearningAI

[Param @ParamSiddh]

If I need to pick ONLY FIVE courses to learn AI & ML from scratch, I would pick:

❯ CS221 - AI
❯ CS229M - ML Theory
❯ CS229 - ML
❯ CS230 - DL
❯ CS336 - LLM

worth more than >$100K. But Stanford is offering them free on YouTube:

[h100envy @h100envy]

Alibaba engineer who leads Qwen explained the future of open agent models in 25 minutes - better than $2000 LLM training courses.

pre-train the base ->SFT -> RLHF -> tool use -> multi-modal -> ship a whole family (chat / VL / coder / math / QwQ).

That loop is why Qwen quietly became the most downloaded open model family on Hugging Face.

Qwen base + Qwen-VL + Qwen-Coder + QwQ reasoning - that's the stack.

Watch and save it, then read the article below.

[freeCodeCamp.org @freeCodeCamp]

If you want to improve your programming skills, try comparing and contrasting similar code.

In this in-depth guide, Evaristo walks you through five different versions of a Rock, Paper, Scissors game in JavaScript.

You'll use System Block Diagrams to analyze each project, dissect their methodologies, and learn how to build mental models.

https://t.co/J7Ii0pLqs6

[codila @0xCodila]

Anthropic Engineer Andrej Karpathy:

"The biggest mistake in AI right now - people are forcing agents to work instead of mastering the model first

We made that mistake in 2016 at OpenAI - It cost us 5 years "

what Karpathy actually means:

step 1 → stop forcing your agent to do everything, understand the model underneath first

step 2 → demos are easy - products take a decade. self-driving proved it - if you skip the foundation, everything breaks

step 3 → the agent is not the product. the foundation is. build that - and agents emerge on their own

"you building agents right now - you're at the forefront. not OpenAI. not DeepMind. you "

watch - bookmark, then read article below ↓

[Rishi Bagree @rishibagree]

Someone, please shed light on what happened in 2014 to cause this sudden acceleration in FDI?

[Akshay 🚀 @akshay_pachaar]

RAG vs. Graph RAG vs. Agentic RAG, clearly explained!

Standard RAG embeds documents into vectors and retrieves the most similar chunks via similarity search. For direct factual lookups, this works well.

But it breaks down when a query needs to connect facts spread across multiple documents. Similarity search retrieves individual chunks, not the relationships between them.

Graph RAG adds a knowledge graph layer on top.

→ During indexing, an LLM extracts entities and relationships from the documents.

→ During retrieval, the system traverses these connections instead of relying on embedding similarity alone.

This is what enables multi-hop queries.

Say a vector DB stores three facts about internal services:

↳ "The checkout service uses payments API."
↳ "The payments API runs on cluster-3."
↳ "Cluster-3 is scheduled for maintenance on Friday."

Someone asks: "Will the checkout service be affected by Friday's maintenance?"

Vector search can likely retrieve facts 1 and 3 because the query mentions "checkout service" and "Friday maintenance."

But it will miss fact 2, which connects the payments API to cluster-3.

That middle fact sits too far from the query in embedding space. It mentions neither "checkout" nor "maintenance," so it never makes it into the retrieved context.

A knowledge graph connects these as linked entities, and graph traversal finds the full path in one query.

Agentic RAG takes a different approach entirely.

Instead of a fixed retrieval pipeline, an LLM agent decides at query time which tools to invoke, which sources to query, and in what order.

Check the visual below to understand the three architectures thoroughly.

One thing to note here is that these three aren't levels of sophistication that you need to graduate through.

Instead, they solve different query types.

↳ Single-hop factual lookups → standard RAG
↳ Multi-hop relationship queries → Graph RAG
↳ Dynamic multi-source tasks with tool use → Agentic RAG

----

Each of these architectures gets better when the underlying retrieval layer is efficient.

I recently wrote about a new RAG approach that cuts corpus size by 40x, reduces tokens per query by 3x, and improves vector search relevance by 2.3x.

The article is quoted below.

[Akshay 🚀 @akshay_pachaar]

Don't train the model, evolve the harness.

I read a brilliant blog post from Hugging Face where they took a frozen open model scoring 0% on a hard legal agent benchmark, left its weights alone, and let an automated loop rewrite only the code around it.

That code layer is the harness, the runtime wrapper that feeds the model context, runs its tool calls, and decides when a run ends.

By the time the loop finished, the system had essentially matched Sonnet 4.6 on the benchmark's headline metric, at roughly 7x lower cost per task. Zero weights changed.

The gain existed because of where the model was failing. The judge only grades files saved in the right place under the exact requested filename, and the model kept doing the legal analysis correctly, then saving it under the wrong name, dropping it in a scratch folder, or never writing it at all.

So the 0% was never measuring legal reasoning. It was measuring the harness.

Hand-tuning that layer is slow and model-specific, so they automated it. A Claude proposer adds exactly one mechanism per iteration, and an outer loop keeps it only if it clearly beats the current best, so accepted mechanisms compound.

What the loop discovered says a lot about where agents actually fail.

→ The biggest single gain was file handling, not intelligence. An automatic step that lands the deliverable exactly where the judge expects it beat every prompt change, with zero extra model tokens.

→ Code fixes transferred across models, prompt playbooks did not. The same harness lifted a smaller model from the same family by 14 points, but the tuned prompts hurt a different model family on tasks it could already finish.

→ The harness mattered more than anything else. Same model, same judge, same tasks, and five different harnesses scored anywhere between 3.5% and 80.1%.

The gains do eventually flatten, and the remaining misses look like real capability gaps. At some point the wrapper runs out of tricks and the model has to carry the work.

But the lesson holds. A benchmark score measures the model and its harness together, and until the harness is fixed, it's impossible to know which one failed.

I highly recommend reading this: https://t.co/3ZIeKhsngn

I also wrote a deep dive on agent harness engineering a while back, covering the orchestration loop, tools, memory, context management, and everything that turns a stateless LLM into a capable agent.

The article is quoted below.

[Yann LeCun @ylecun]

Exactly. I've been disseminating a similar message for years.

The concentration of power in AI and the desire for control is by far the biggest danger of AI. It could lead to a few private companies and/or countries being in control of access to information, access to knowledge, and access to the tools of economic expansion.
It's a kind of medieval obscurantism akin to the Ottoman empire banning the use of the printing press for 200 years, in part to keep control of the dogma, but also to protect the corporation of the calligraphers and scribes.

Relevant historical bits about the Internet:
1. It took a deliberate decision by Al Gore and Bill Clinton to open up access of what was then ARPAnet to commercial entities and to the public, against the desires of the entrenched telecom industry. During a public roundtable about the "information superhighway" in 1993, the CEO of AT&T told Gore and Clinton "leave it to us". Gore said no.
2. In the late 1980s, setting up an Internet presence required buying proprietary hardware with proprietary OS and software stack from Sun Microsystems, HP, IBM, or Dell. By the 2000s, all of this was wiped out by commodity hardware, Linux, Apache, and an entirely free/open software stack. This migration to open platforms was the result of market forces.

Infrastructure wants to be open.
Foundation models are becoming an infrastructure and will inevitably become commoditized.
Long term, the money is in the application layer, which is what I, Arthur Mensch, Alex Karp, and others have been saying.

[Avi Chawla @_avichawla]

Prompt, context, harness & loop engineering, clearly explained!

An agent is a while loop with four layers of engineering wrapped around it:

- Prompt engineering
- Context engineering
- Harness engineering
- Loop engineering

Each one wraps the last, and the model sits in the middle, so none of them compete with the others. Instead, they just zoom one level further out.

> Prompt engineering:

This defines the input the model sees on one call, often composed of a role, instructions, examples, and an output format.

The techniques here alter the internal computation and reasoning the model goes through due to the wording it sees:

- Chain-of-thought makes it work in steps before answering
- Few-shot examples define the format and the edge cases
- A JSON schema or XML tags make the output parseable by code
- Self-consistency samples a few chains and takes the majority

> Context engineering:

It's everything the model sees on a turn, not just the prompt. That includes the query, retrieved docs, memory, prior turns, and tool outputs from earlier steps.

The window is finite and fills up fast, so the engineering work is to rank inputs and cut everything that isn't pulling weight.

You do this by:

- Retrieving only the chunks relevant to the query, then reranking them
- Keeping key facts out of the middle, where accuracy drops
- Summarizing old turns, evict stale outputs, push big blobs to files

> Harness engineering:

It's the code around the model that defines the tools, parses the calls, retries on failure, and can route work to sub-agents so one handles retrieval and another handles code.

A verifier then grades the result by running tests, validating a schema, etc.

Prompt and context involve getting one call right. The harness involves everything that has to happen around that call for it to run in a real system.

> Loop engineering:

In the usual setup, you manage the outer loop, i.e, you write a prompt, read the turns the agent runs, write the next prompt, and repeat, while catching failures.

This layer hands that job to the agent itself. It kicks off on a schedule or an event, and runs many turns with no prompt in between.

A loop inherently doesn't know when it's finished. An agent can report that it's done and halt while the tests still fail. So the stop can't be the agent's word, but rather it has to be a real signal, like:

- A turn and token cap to stop stuck runs
- A no-progress detector to catch repeated calls
- A completion check to verify the goal with a separate model or a deterministic test

By this layer, you're operating on the whole run, so the engineering moves from writing each prompt to setting the goal and the stop conditions up front and letting it run.

If you want to dive deeper into loop engineering, my co-founder wrote a full breakdown of that outer loop.

It goes from the basic while loop to a run that finishes on its own, with the code behind each part, and the parts that are hard to get right, like knowing when to stop, context rot over a long run, and keeping the checker separate from the maker.

Read it below.

[freeCodeCamp.org @freeCodeCamp]

Quantum computing might sound like something people in lab coats do behind closed doors.

But in this beginner-friendly guide, @casweb_dev teaches you how to build a quantum circuit in Python with Qiskit.

You'll learn key concepts like qubits, quantum gates, superposition, entanglement, Bell States, simulators, and more.

https://t.co/cCQhKZQdKF

[vLLM @vllm_project]

5x lower token costs on DeepSeek V4 in one month!

Highlighting the vLLM community at work: day-zero recipes, then relentless optimization across kernels, scheduling, and serving. Every PR counts. 🚀

[freeCodeCamp.org @freeCodeCamp]

What if an AI agent could run its own LLM training experiments overnight?

In this article, Ishaan walks you through Andrej Karpathy’s autoresearch project.

You'll learn how the agent edits https://t.co/nA2fCP1ATa, runs fixed 5-minute experiments, tracks validation bits per byte, keeps winning changes, and more.

https://t.co/X0milbTOZ3