Sirjan Bhandari 🇳🇵

tech and chess ♚

[Yuchen Jin @Yuchenj_UW]

a friend: “I burned 15B tokens last week.”

me: “what did you build?”

him: “nothing, mostly Anthropic revenue.”

[Google AI Studio @GoogleAIStudio]

https://t.co/mIXzM657cR

[Carlos E. Perez @IntuitMachine]

Anthropic Claude's Soul Document is an informative approach to AI alignment and a major revelation about the nature of advanced AGI. Here's my analysis using my conceptual frameworks (i.e., QPT).

[Hasan Toor @hasantoxr]

🚨 Microsoft just quietly dropped a tool that turns ANY document into LLM-ready data in seconds.

It's called MarkItDown, a lightweight Python library that converts PDFs, Word, Excel, PowerPoint, images, audio, and YouTube URLs into clean Markdown your LLM can actually use.

No custom parsers. No brittle pipelines. No preprocessing hell.

Built by the AutoGen team and battle-tested across 87K GitHub stars.

The numbers don't lie:
→ pip install markitdown and you're converting files in under 60 seconds
→ 10+ file formats supported out of the box
→ Native MCP server for direct Claude Desktop integration

And it works everywhere:
→ Command line: markitdown file.pdf > doc .md
→ Python API: 3 lines of code
→ Docker
→ Azure Document Intelligence for enterprise OCR

100% Opensource. MIT license.

This is the document preprocessing tool your RAG pipeline has been waiting for LLM-ready output without the LLM-ready headache.

Link in the first comment 👇

[Connor Davis @connordavis_ai]

Holy shit… this paper might be the most important shift in how we use LLMs this entire year.

“Large Causal Models from Large Language Models.”

It shows you can grow full causal models directly out of an LLM not approximations, not vibes actual causal graphs, counterfactuals, interventions, and constraint-checked structures.

And the way they do it is wild:

Instead of training a specialized causal model, they interrogate the LLM like a scientist:

→ extract a candidate causal graph from text
→ ask the model to check conditional independencies
→ detect contradictions
→ revise the structure
→ test counterfactuals and interventional predictions
→ iterate until the causal model stabilizes

The result is something we’ve never had before:

a causal system built inside the LLM using its own latent world knowledge.

Across benchmarks synthetic, real-world, messy domains these LCMs beat classical causal discovery methods because they pull from the LLM’s massive prior knowledge instead of just local correlations.

And the counterfactual reasoning?

Shockingly strong.

The model can answer “what if” questions that standard algorithms completely fail on, simply because it already “knows” things about the world those algorithms can’t infer from data alone.

This paper hints at a future where LLMs aren’t just pattern machines.
They become causal engines systems that form, test, and refine structural explanations of reality.

If this scales, every field that relies on causal inference economics, medicine, policy, science is about to get rewritten.

LLMs won’t just tell you what happens.

They’ll tell you why.

[Tech with Mak @techNmak]

Meta just solved RAG's biggest bottleneck.

30× faster decoding. Zero accuracy loss.

The problem nobody talks about:

When you feed an LLM 80 retrieved passages, only 5-10 are actually useful.

The rest? Dead weight. But you're computing attention for ALL of them.

The math is brutal:

Traditional RAG with 16K context: → 100+ seconds to first token → 10× throughput drop → Massive memory waste

What REFRAG does:
Compresses context chunks into single embeddings.

Instead of processing 16,384 tokens → Process 1,024 chunk embeddings.

The results:
✓ 30.85× faster time-to-first-token
✓ Zero perplexity loss
✓ 16× context extension (4K → 64K tokens)
✓ 3.75× better than previous SOTA

Why it works:
RAG contexts have sparse attention patterns. Most retrieved passages don't interact. REFRAG exploits this with:

1./ Precomputable embeddings - Cached from retrieval, reused across inferences
2./ RL-based compression - Smart policy decides what to compress
3./ Works anywhere - Unlike previous methods, compresses at any position

Real impact:
• 8 passages at single-passage latency
• Better accuracy with weak retrievers
• Handles unlimited conversation history
• No model architecture changes needed

This changes RAG economics: More context + Lower latency.

(Link to the Meta paper in comments)

♻️ Repost to save someone $$$ and a lot of confusion.
✔️ You can follow @techNmak, for more insights.

[Karan🧋 @kmeanskaran]

⏳ Day 3: Learning AI Agents for MLOps Project

Prompt Engineering, RAG, and simple agents are old!

Here are 9 advanced Agentic AI concepts you should know heading into 2026.

1. Guardrails:
Programmable rules that prevent your agent from going rogue. They block hate speech, PII leaks, off-topic responses, or hallucinations before the user sees them.

2. Runtime/Orchestration:
The brain that manages execution flow: calling tools, waiting for results, chaining agents, looping, escalating to humans, and replying.

3. Context Engineering (detailed post coming):
In 2026, context engineering > prompt engineering. With massive context windows (128k–1M tokens), you must compress history, retrieve relevant memories, rank documents, and discard noise, or even the best model becomes stupid.

4. Human-in-the-Loop (HITL):
For anything high-stakes (money, health, law), keep a human in the loop. My setup: agent drafts → human approves/edits → agent learns and continues. Adds seconds, saves weeks of regret.

5. Multi-Agent Systems:
One agent is fine; a team of 4–5 specialized agents is insane. My typical setup:
- one researches
- one writes
- one fact-checks
- one summarizes
- one evaluates

6. Advanced Retrieval (beyond basic RAG):
Tricks that actually work:
- rewrite the user query
- use HyDE
- retrieve parent documents, not small chunks
- filter by metadata
- rerank with bge-reranker or Cohere
- fuse multiple queries

7. Long-Term Memory:
Agents must remember users forever. Store everything in a vector DB (Qdrant/Pinecone) plus a user profile so next month it still knows your name, company, and coding style.

8. Episodic Memory:
Episodic memory captures 20–50 key user statements as short, timestamped summaries and embeds them in a vector DB. On every turn, retrieve top-3 most similar past episodes via cosine search.

9. Semantic Caching:
Biggest free win: if a new question is 95% similar to a past one, instantly return the cached answer. Saves money and drops latency from seconds to milliseconds. Redis + embeddings is glorious.

Today I reviewed these concepts and over the last 10 months, AI agents have evolved tremendously. The community identified real problems and focused on reliable, detailed outputs.
In a few months, building an AI agent will be 2–3 lines of code tuned by hyperparameters.

That’s it for today. I started designing the AI agent for my MLOps project.
Next update: implementation!

[Leonie @helloiamleonie]

Memory in AI agents seems like a logical next step after RAG evolved to agentic RAG.

RAG: one-shot read-only
Agentic RAG: read-only via tool calls
Memory in AI agents: read-and-write via tool calls

Obviously, it's a little more complex than this.

I make my case here: https://t.co/KyzloUFmw4

[Python Developer @PythonDvz]

RAG was supposed to make LLMs smarter.
Ground them in facts. Give them memory.

But the truth?

Most RAG systems today are just fancy search engines—fetching chunks and hoping the model figures it out.

That’s not intelligence.

The real upgrade is Agentic RAG.

Tools like Glean, Perplexity, and Harvey don’t just retrieve… they reason.
They decide what to fetch, when to fetch, or whether they should fetch anything at all.

This changes everything:

• No blind embeddings
• No random chunk dumps
• Real, layered memory
• APIs, search, and tools inside the reasoning loop

The LLM stops guessing and starts thinking.

[Seohong Park @seohong_park]

Is RL really scalable like other objectives?

We found that just scaling up data and compute is *not* enough to enable RL to solve complex tasks. The culprit is the horizon.

Paper: https://t.co/KsNZgk782S

Thread ↓

[yobibyte @y0b1byte]

Excellently written paper

[Avi Chawla @_avichawla]

Let's fine-tune Qwen 3 (100% locally):

[Santiago @svpino]

People calling MCP just “tool calling” fundamentally misunderstand the protocol.

MCP is much more than that. The protocol defines a set of primitives that go well beyond function invocations.

Server-side primitives (capabilities the server exposes to the model):

• Tools - Executable functions that the model can invoke through the server
• Prompts - These are instructions or templates that can guide the model
• Resources - Structured data or documents that can enrich the model’s context or memory

Client-side primitives (capabilities the client exposes to the server):

• Roots -  Entry points into the client's filesystem (if access is granted)
• Sampling - A mechanism that allows the server to ask the host to generate completions from its local model

On top of it, the protocol provides authorization capabilities (using OAuth 2.1) to enable clients to make requests to restricted servers.

Every major company is all-in on MCP: Google, OpenAI, Anthropic, Zapier, Docker, Postman, GitHub.

Most modern IDEs support MCP: Cursor, JetBrains, Visual Studio Code, Windsurf.

Every startup I talk to supports MCP or is currently adding support to it.

If you still think MCP is a fad, I don't know what else to tell you.

[Akshay 🚀 @akshay_pachaar]

10 MCP, AI Agents, and RAG projects for AI Engineers (with code):

[Akshay 🚀 @akshay_pachaar]

You can download them from this GitHub repo: https://t.co/d7WEBex6dw

[Matthew Berman @MatthewBerman]

We knew very little about how LLMs actually work...until now.

@AnthropicAI just dropped the most insane research paper, detailing some of the ways AI "thinks."

And it's completely different than we thought.

Here are their wild findings: 🧵

[Matthew Berman @MatthewBerman]

Finding 2: LLMs Plan Ahead!

Even though they output word-by-word, models like Claude plan ahead, even non-thinking models.

When writing poetry, it was "thinking" of potential rhyming words for the end of the line before even starting the line itself.

It's not just next-token prediction!

[The AI Timeline @TheAITimeline]

🚨This week's top AI/ML research papers:

- GPT-4o System Card: Native Image Generation
- Anthropic's On the Biology of a LLM
- Gemma 3 Technical Report
- Qwen2.5-Omni Technical Report
- Reasoning to Learn from Latent Thoughts
- Defeating Prompt Injections by Design
- Scaling Vision Pre-Training to 4K Resolution
- When Less is Enough
- Interpreting Reasoning Features in LLMs via SAE
- Test-Time Scaling for Video Generation
- xKV: Cross-Layer SVD for KV-Cache Compression
- Scaling Laws of Synthetic Data for LMs
- ImageGen-CoT
- Video-R1
- RL for Adaptive Planner Parameter Tuning
- I Have Covered All the Bases Here
- CoLLM
- Aether
- ReSearch

overview for each + authors' explanations
read this in thread mode for the best experience

[LG AI Research @LG_AI_Research]

🚀 Breaking News! We’re thrilled to introduce #EXAONEDeep, a next-generation AI model designed to enhance reasoning capabilities—Evolving into ‘Agentic AI‘ for real-world industry solutions!

🧠 Specialized in math, science, and coding tasks, EXAONE Deep pushes the boundaries of AI’s role in both professional fields and everyday life.

🔹 32B: Achieved #1 on AIME, outperforming competitor at just 5% of its model size
🏆 7.8B & 2.4B: Dominated all major benchmarks, securing first place

🔗 [Our Model]https://t.co/H8E283UJGd
🔗 [Our Blog]https://t.co/OyakatN7DK

[ℏεsam @Hesamation]

Transformers without Normalization

the paper is based on this idea: the output of a transformer layer produces a tanh-like S-cureve

they use "dynamic" tanh with a learnable 𝛼 parameter instead of layer norms.

> less compute
> faster convergence
> simpler backprop