Umar

AI/ML Engineer who builds production LLMs, RAG, agents and CV systems. From traditional ML to Transformers. Open to opportunities.

[Umar @Umarfarook_]

Shipped a BigQuery MCP server today.

Built it because I got tired of two things:

1) queries accidentally scanning 50GB because of a bad join
→ now every query dry-runs and gets blocked if it crosses a cap

2) "accuracy" claims with no proof
→ comes with an eval harness

[clem 🤗 @ClementDelangue]

A study from @Stanford showed that 71.3% of chatgpt queries could be accurately answered by a local model. I suspect a major part of enterprise AI workloads could be run locally too for free (compared to the massive costs of frontier API cost).

Also, it reduces the risk of these workloads being taken away from you because you own the models instead of renting them - which sounds like a good idea these days haha.

That's why we're introducing the ability for everyone to filter AI models on @huggingface based on your local hardware.

For me, there are 800k+ public models that fit on my M5 24GB and that I can use easily thanks to llamacpp.

Let's go local AI!

[Thariq @trq212]

Lots of people asked how I used Fable to edit its own launch video so I made a video about that!

TLDR it wrote a lot of code & tool calls to use transcription services, ffmpeg, do colorgrading, use the figma mcp, make remotion UI and render it.

I didn't touch a video editor.

[Claude @claudeai]

Fable 5 is state-of-the-art on nearly all tested benchmarks, with exceptional performance in software engineering, knowledge work, scientific research, and vision.

The longer and more complex the task, the larger Fable 5’s lead over our other models.

[NVIDIA AI @NVIDIAAI]

This #CVPR2026 paper from our research team is trending #1 on @HuggingFace 🤗

Meet LocateAnything: a vision-language detection model that rethinks bounding box prediction. For AI agents and robots, “seeing” is only useful if a model can pinpoint where something is fast enough to act.

Trained on 138M high-quality samples, LocateAnything decodes bounding boxes in parallel instead of one coordinate at a time, improving localization accuracy while dramatically increasing throughput for visual grounding and detection.

Project page: https://t.co/O7JMe8tzFM

[AilaunchX @Ai_Tech_tool]

🚨 Anthropic just showed a 27-minute workshop on how to actually do prompts for Claude.

Taught by the people who built it.

Free. No registration. No paywall.

I've seen $300 courses that don't cover what they teach in the first 8 minutes.

Watch it and bookmark it now.

[Sebastian Raschka @rasbt]

The MiniMax M2 series was one of the most widely used open-weight LLM series earlier this year. Now, we got a technical report with some interesting tidbits. I summarized some of them below:

1. Full attention as an anti-trend?:

They tried hybrid sliding-window attention variants (like so many others, like Xiaomi MiMo, Laguna, Gemma 4, Arcee, Olmo 3, etc.). But even though there were efficiency gains, they said that the production-quality tradeoffs were not worth it for M2.

2. Linear and sparse attention deployment issues:

They found that linear and sparse attention are attractive on paper because they reduce the cost of long-context attention, but they are harder to make work well in a production agent system.

In particular, they found that these efficient attention variants may be more fragile when KV-like state or intermediate memory is stored in lower precision.

Also, they have worse prefix caching support, which matters a lot when using coding agents (which reuse a lot of the context).

3. Fine-grained Mixture-of-Experts (MoEs) are useful:

Finally a recent MoE ablation study! It's only on the 2B-active parameter scale, but hey, better than nothing.

Concretely, they compare a baseline with 32 experts and top-2 routing against a fine-grained setup with 128 experts and top-8 routing.

The fine-grained setup improves MATH from 19.6 to 24.1 and HumanEval from 29.7 to 32.5. That's clearly a win for more fine-grained experts (confirming what the DeepSeek MoE paper reported ~2 years ago).

4. Sophisticated agent pipeline

It's probably no surprise, but this papers confirms that training for agent-like behavior on software engineering task is now a big component of the training pipeline.

They mine GitHub pull requests, builds runnable Docker environments, extracts task-specific test rewards, etc.

5. Interleaved thinking for context management

Interestingly, they found that removing reasoning blocks from previous turns results in worse performance, especially in multi-step agent tasks. (Another point why long-context support is so important these days).

6. Speed rewards

It's common to have token usage penalties, but what's interesting is that the MiniMax team adds a task-completion-time reward that depends on wall-clock time. This is to minimize unnecessary (slow) tool calls. Also, I'm thinking that this would encourage agent parallelization (if supported by the harness)

7. Self-evolution

Looks like self-evolution is also already a big design component of open-weight LLMs. E.g., the paper says that M2.7 already handles 30 to 50 percent of the daily RL iteration workload, modifies its own scaffold, and completed a 100-round autonomous scaffold optimization cycle with a 30 percent gain on internal evaluations.

[Ahmad @TheAhmadOsman]

DROP EVERYTHING

The ultimate step-by-step projects roadmap for BECOMING an AI Researcher is now available online to read FOR FREE

Covers building

- Tokenizers / embeddings
- Positional methods
- Attention / multi-head attention
- Transformer blocks
- Training loops / objectives
- Sampling dashboards
- Speculative decoding
- KV cache / MQA / GQA / MLA
- Long context
- FlashAttention / hardware budgets
- MoE routers
- State-space / diffusion LMs
- Data pipelines / synthetic data
- Scaling laws
- SFT / DPO / RLHF / GRPO / RLVR
- Quantization
- Serving systems
- Evaluation harnesses
- RAG / tools / agents
- Multimodal adapters
- Interpretability / safety
- Full capstone model system

The loop for every project

- Build it
- Plot it
- Break it
- Explain it
- Ship the artifact

You should read this, and if you cannot now then you most definitely wanna bookmark it for later

DM me when you're working at a frontier lab

[CJ Zafir @cjzafir]

Do something different this weekend.

Become a PRO in AI Model Fine-tuning.

Paste this prompt in Codex/ChatGPT/Claude/Grok.

"You are an expert AI engineer and teacher.

Your job is to teach me modern LLM engineering and fine-tuning concepts from beginner to advanced level using very simple daily-life language.

Teach me step-by-step like a real mentor. Assume I am smart but new to the topic.

Foundations:

- LLM basics
- How AI models work
- Tokens
- Tokenization
- Context windows
- Embeddings
- Transformers
- Attention mechanism
- Parameters
- Training vs inference
- Open-source vs closed-source models

Datasets & Training:

- SFT datasets
- Instruction tuning
- Preference datasets
- Synthetic datasets
- Data curation
- Dataset cleaning
- Dataset formatting
- Fine-tuning basics
- Continued pretraining
- Hallucination reduction

Fine-Tuning:

- LoRA
- QLoRA
- DPO
- RLHF
- Quantization
- Model checkpoints
- Adapter tuning
- GGUF models

Inference & Optimization:

- KV cache
- Flash Attention
- Speculative decoding
- Inference optimization
- Model serving
- Batch inference
- GPU basics
- VRAM basics
- Latency vs quality tradeoffs

Local AI Ecosystem:

- llama.cpp
- Ollama
- vLLM
- MLX
- Hugging Face
- Unsloth
- Axolotl
- PEFT
- TRL library

RAG & Memory:

- RAG
- Vector databases
- Chunking
- Retrieval pipelines
- AI memory systems
- Semantic search

Agents & Workflows:

- Prompt engineering
- System prompts
- Tool calling
- Function calling
- AI agents
- Agentic workflows
- Multi-agent systems
- Browser agents

Model Types:

- VLMs
- SLMs
- Dense models
- MoE models
- Coding models
- Reasoning models

Deployment:

- Local inference
- On-device AI
- API serving
- Cloud GPUs
- Edge AI basics

Evaluation:

- AI benchmarks
- Human evals
- Cost-per-token analysis
- Speed benchmarking
- Quality benchmarking

Real-World Skills:

- Building chatbots
- Building AI copilots
- AI automation
- AI SaaS workflows
- AI coding workflows
- AI orchestration systems
- AI product thinking

Start from the absolute basics and gradually make me advanced.

Rules:

- Use simple English only
- Avoid academic jargon unless necessary
- Explain every difficult word in plain language
- Use real-world analogies and daily-life examples
- Use small code snippets when useful
- Show practical use cases
- Compare concepts side-by-side when helpful
- Teach from fundamentals first, then advanced concepts
- At the end of each topic:
- give a short summary
- give a simple mental model
- give beginner mistakes to avoid
- give a small exercise/project

I want deep understanding, not memorization."

Thank me later.

[Susan Zhang @suchenzang]

all this ai math talk makes me realize:

- there's not enough professional mathematicians around who waste their time on X

- there's even fewer combinatorial geometrists doing the above

- we all worship math as a final beacon of human reasoning intelligence

- we all secretly want to be smarter than mathematicians

- the people who know the least about math and ai/llms always have the most opinions

[DAIR.AI @dair_ai]

NEW paper worth reading.

A full agentic workflow can be distilled into model weights and run at roughly 100x lower inference cost while preserving near-frontier task quality.

The workflow includes multi-step LLM calls, tool invocations, intermediate scratchpads, and decision structure.

Instead of expressing all of that at runtime through a framework, the paper amortizes the behavior into a compiled model through targeted distillation.

This is the strongest economic argument for agent compilation so far. Runtime loops are flexible, but expensive. Compiled workflows trade some flexibility for a massive inference-cost reduction.

Paper: https://t.co/4k4urYOAeQ

Learn to build effective AI agents in our academy: https://t.co/LRnpZN7L4c

[Umar @Umarfarook_]

MIT licensed. on PyPI.

Repo: https://t.co/7YqrX905CR
install: uvx mcp-bigquery-evals

[Umar @Umarfarook_]

Shipped a BigQuery MCP server today.

Built it because I got tired of two things:

1) queries accidentally scanning 50GB because of a bad join
→ now every query dry-runs and gets blocked if it crosses a cap

2) "accuracy" claims with no proof
→ comes with an eval harness