Rahul Rajan

Paving a way into the field of Data Science|#NontechtoTech |Learning ML,SQL,Python,Power Bi,Tableu.
I also publish blogs at

[Rahul Rajan @RahulR9191]

@everestchris6 Guide

[Rahul Rajan @RahulR9191]

@akshay_pachaar @driscollis Congratulations Akshay!That's really awesome!!

[Inference @inference_net]

The LLM Engineering Roadmap.

If you want to start today, here's the roadmap👇

1️⃣ LLM Foundations
Start by understanding Python and LLM APIs and how they work.
Learn prompt engineering, structured outputs, and tool use.

↳ Python/Typescript Basics
↳ LLM APIs
↳ Prompt Engineering
↳ Structured Outputs
↳ Function Calling

2️⃣ Vector Stores
Before building anything, you need to understand how text becomes vectors.
Learn embedding models, chunking strategies, and similarity search.

↳ Embedding Models (OpenAI Ada, Cohere, BGE)
↳ Vector Databases (Pinecone, Qdrant, ChromaDB, FAISS)
↳ Chunking Strategies
↳ Similarity Search

3️⃣ Retrieval-Augmented Generation (RAG)
This is how LLMs answer questions using your data.
You learn how to retrieve context and feed it correctly.

↳ Orchestration Frameworks (LangChain, LlamaIndex)
↳ Ingesting Documents
↳ Retrieval Methods (Dense, BM25, Hybrid)
↳ Reranking
↳ Prompt Templates

4️⃣ Advanced RAG
This steps helps you understand how to make RAGs reliable and accurate.

↳ Query Transformation
↳ HyDE
↳ Corrective RAG
↳ Self-RAG
↳ Graph RAG

5️⃣ Fine-Tuning
Sometimes prompts are not enough for a specialised use case.
Fine-tuning will help you understand how models learn domain-specific behaviour.

↳ Data Preparation
↳ LoRA, QLoRA, DoRA
↳ SFT, DPO, RLHF
↳ Training Tools (Unsloth, Axolotl, HF TRL)

6️⃣ Inference Optimization
Once systems work, they need to be fast and affordable.
This step focuses on learning performance and cost efficiency.

↳ Quantization (GGUF, GPTQ, AWQ)
↳ Serving Engines (vLLM, TGI, llama.cpp)
↳ KV Cache
↳ Flash Attention
↳ Speculative Decoding

7️⃣ Deployment
Models are useless if they stay in notebooks.
Here you learn how to ship LLM systems to users.

↳ GPU Scheduling
↳ Cloud Platforms (AWS Bedrock, GCP Vertex AI)
↳ Docker, Kubernetes
↳ FastAPI, Streaming (SSE)

8️⃣ Observability
This step helps you track quality, latency, and cost.

↳ Tracing (LangSmith, Langfuse, Arize Phoenix)
↳ Latency (TTFT)
↳ Token Usage
↳ Cost Tracking

9️⃣ Agents
Agents allows LLMs to plan and use tools.
Learn them to understand how LLMs solve multi-step and complex tasks.

↳ Frameworks (LangGraph, CrewAI, Autogen)
↳ Function Calling
↳ Memory Systems
↳ Patterns (ReAct, Plan-and-Execute, Multi-Agent)

🔟 Production & Security
Production LLM systems can fail in subtle ways.
This step helps you prevent misuse, outages, and cost spikes.

↳ Prompt Injection Defense
↳ Guardrails (NeMo, Guardrails AI)
↳ Semantic Caching
↳ Fallbacks & Rate Limiting

♻️ Repost if you found this insightful

Follow us for more AI engineering content!

[LlamaIndex 🦙 @llama_index]

Can filesystem tools really replace vector search? We put agentic file exploration to the test against traditional RAG.

Our experiment with fs-explorer agent vs. hybrid RAG revealed some surprising insights about when each approach shines:

🏃 RAG is faster - averaging 3.81 seconds quicker thanks to fewer LLM calls and consistent network requests
🎯 Filesystem agents are more accurate - scoring 2 points higher on correctness by accessing full file context instead of chunked fragments
📈 Scale changes everything - at 100-1000 documents, RAG outperforms filesystem exploration in speed and maintains quality
⚖️ Context matters most - filesystem tools excel with smaller files that fit in the LLM's context window, while RAG handles massive document collections

The verdict? It depends on your use case. Filesystem agents work great for smaller, focused document sets where accuracy trumps speed. RAG remains king for large-scale applications requiring real-time responses.

Read the full experimental analysis by @itsclelia and see the results for yourself: https://t.co/DMG3jnYrKq

[Ahmad @TheAhmadOsman]

step-by-step LLM Engineering Projects

LOCK IN FOR A FEW WEEKS ON THESE PROJECTS
AND YOU WILL BE GRATEFUL FOR IT LATER

each project = one concept learned the hard (i.e. real) way

Tokenization & Embeddings

> build byte-pair encoder + train your own subword vocab
> write a “token visualizer” to map words/chunks to IDs
> one-hot vs learned-embedding: plot cosine distances

Positional Embeddings

> classic sinusoidal vs learned vs RoPE vs ALiBi: demo all four
> animate a toy sequence being “position-encoded” in 3D
> ablate positions—watch attention collapse

Self-Attention & Multihead Attention

> hand-wire dot-product attention for one token
> scale to multi-head, plot per-head weight heatmaps
> mask out future tokens, verify causal property

transformers, QKV, & stacking

> stack the Attention implementations with LayerNorm and residuals → single-block transformer
> generalize: n-block “mini-former” on toy data
> dissect Q, K, V: swap them, break them, see what explodes

Sampling Parameters: temp/top-k/top-p

> code a sampler dashboard — interactively tune temp/k/p and sample outputs
> plot entropy vs output diversity as you sweep params
> nuke temp=0 (argmax): watch repetition

KV Cache (Fast Inference)

> record & reuse KV states; measure speedup vs no-cache
> build a “cache hit/miss” visualizer for token streams
> profile cache memory cost for long vs short sequences

Long-Context Tricks: Infini-Attention / Sliding Window

> implement sliding window attention; measure loss on long docs
> benchmark “memory-efficient” (recompute, flash) variants
> plot perplexity vs context length; find context collapse point

Mixture of Experts (MoE)

> code a 2-expert router layer; route tokens dynamically
> plot expert utilization histograms over dataset
> simulate sparse/dense swaps; measure FLOP savings

Grouped Query Attention

> convert your mini-former to grouped query layout
> measure speed vs vanilla multi-head on large batch
> ablate number of groups, plot latency

Normalization & Activations

> hand-implement LayerNorm, RMSNorm, SwiGLU, GELU
> ablate each—what happens to train/test loss?
> plot activation distributions layerwise

Pretraining Objectives

> train masked LM vs causal LM vs prefix LM on toy text
> plot loss curves; compare which learns “English” faster
> generate samples from each — note quirks

Finetuning vs Instruction Tuning vs RLHF

> fine-tune on a small custom dataset
> instruction-tune by prepending tasks (“Summarize: ...”)
> RLHF: hack a reward model, use PPO for 10 steps, plot reward

Scaling Laws & Model Capacity

> train tiny, small, medium models — plot loss vs size
> benchmark wall-clock time, VRAM, throughput
> extrapolate scaling curve — how “dumb” can you go?

Quantization

> code PTQ & QAT; export to GGUF/AWQ; plot accuracy drop

Inference/Training Stacks:

> port a model from HuggingFace to Deepspeed, vLLM, ExLlama
> profile throughput, VRAM, latency across all three

Synthetic Data

> generate toy data, add noise, dedupe, create eval splits
> visualize model learning curves on real vs synth

each project = one core insight. build. plot. break. repeat.

> don’t get stuck too long in theory
> code, debug, ablate, even meme your graphs lol
> finish each and post what you learned

your future self will thank you later

[Sydney Runkle @sydneyrunkle]

Most projects don't need a multi-agent system. But when you do...

I spent the last few weeks researching 4 architectural patterns to find out when you actually need each one.

👥 Subagents (centralized control)
💡 Skills (progressive disclosure)
🔄 Handoffs (sequential workflows)
🧭 Router (parallel synthesis)

Check out my blog post with a decision framework, benchmarks, and tutorials for each pattern!

📖 https://t.co/UWy14K6OiH

[alphaXiv @askalphaxiv]

Train your own deep research agent in under a day

Agent-R1 uses RL to teach agents proper tool use over multi-turn interactions, achieving 3x better performance than RAG

We provide a step-by-step tutorial of the work: MDP extensions, action masking, and more. See below!

[Avi Chawla @_avichawla]

Layers of observability in AI systems, explained visually:

If you’re deploying LLM-powered apps to real users, you need to know what’s happening inside your pipeline at every step.

Here’s the mental model (see the attached diagram):

Think of your AI pipeline as a series of steps. For simplicity, consider RAG.

A user asks a question, it flows through multiple components, and eventually, a response comes out.

Each of those steps takes time, each step can fail, and each step has its own cost. And if you’re only looking at the input and output of the entire system, you will never have full visibility.

This is where traces and spans come in.

> A Trace captures the entire journey, from the moment a user submits a query to when they get a response. Look at the "Trace" column in the diagram below. One continuous bar that encompasses everything.

> Spans are the individual operations within that trace. Each colored box on the right represents a span.

Let’s understand what each span captures in this case:

- Query span: User submits a question. This is where your trace begins. You capture the raw input, timestamp, and session info.

- Embedding Span: The query hits the embedding model and becomes a vector. This span tracks token count and latency. If your embedding API is slow or hitting rate limits, you’ll catch it here.

- Retrieval Span: The vector goes to your database for similarity search. Our observation suggests that this is where most RAG problems hide, with the most common reasons being bad chunks, low relevance scores, wrong top-k values, etc. The retrieval span exposes all of it.

- Context Span: In this span, the retrieved chunks get assembled with your system prompt. This span shows you exactly what’s being fed to the LLM. So if the context is too long, you’ll see it here.

- Generation Span: Finally, the LLM produces a response. This span is usually the longest and most expensive. Input tokens, output tokens, latency, reasoning (if any), etc., everything is logged for cost tracking and debugging.

This should make it clear that without span-level tracing, debugging is almost impossible.

You would just know that the response was bad, but you would never know if it was due to bad retrieval, bad context, or the LLM’s hallucination.

Cost tracking is another big one. Span-level tracking lets you see where the money is actually going.

One more thing: AI systems degrade over time. What worked last month might not work today. Span-level metrics let you catch drift early and tune each component independently.

Lastly, to clarify, a Trace is the container that ties everything together for a single request. When a user submits a query, a unique Trace ID gets generated. Every span that happens as part of that request carries this same Trace ID.

So if your system processes 1000 queries, you have 1000 traces. Each trace contains multiple spans (embedding, retrieval, generation, etc.), but they’re all linked by that one Trace ID.

The “Trace” column shows one long continuous bar. That’s the trace - it starts when the query comes in and ends when the response goes out. All the colored spans on the right are nested inside it, linked by the same Trace ID.

If you want to see how component-level observability + evals are implemented in practice, I have shared a snippet below that uses the DeepEval open-source framework.

[Tech with Mak @techNmak]

This is what a production-ready GenAI repo actually looks like:

📂 config/ (Prompts & Model settings)
📂 src/llm/ (Abstracted clients)
📂 src/prompt_engineering/ (Dynamic chain logic)
📂 data/cache/ (Don't pay for the same API call twice)

Structure isn't overhead. Structure is sanity.

Who is building like this? 👇

[Rahul Rajan @RahulR9191]

If you use LLMs,this cheatsheet is non-negotiable:
#LLM #LLMs #genai #DataScience #techtwitter #buildinpublic

[Daily Dose of Data Science @DailyDoseOfDS_]

First Principles Approach to MLOps!

MadeWithML is the best place to learn how to combine AI/ML with software engineering to build production-grade solutions.

These fundamentals are directly applicable to LLMOps as well.

100% free and open-source.

[Victoria Slocum @victorialslocum]

Almost every app I've seen pre-chunks their documents for RAG.

We built a system that chunks at query time instead - here's what we learned:

Most RAG systems use 𝗽𝗿𝗲-𝗰𝗵𝘂𝗻𝗸𝗶𝗻𝗴: breaking documents into smaller pieces before embedding and storing them. You make upfront decisions about chunk size and boundaries, then everything's pre-computed and indexed for fast retrieval.

But here's the problem: choosing the right chunking strategy is 𝘩𝘢𝘳𝘥. Should you use fixed-size chunks? Semantic chunking? Hierarchical? The decision has huge downstream impacts on your RAG system's performance, and I've seen tons of developers struggle with this.

So we built 𝗽𝗼𝘀𝘁-𝗰𝗵𝘂𝗻𝗸𝗶𝗻𝗴 into Elysia, our open source agentic RAG framework.

Instead of chunking upfront, Elysia chunks at query time:
• Initial searches use document-level vectors (good overview, but not granular)
• When documents exceed a token threshold 𝘢𝘯𝘥 prove relevant to the query, Elysia dynamically chunks them
• Chunks get stored in a parallel, quantized collection with cross-references to original documents
• Subsequent queries leverage previously chunked content (the system gets more efficient over time)

This means you can create dynamic chunking strategies specific to the context of the user's query. Different document types could use different methods - code chunked by function boundaries, prose using semantic chunking. Also, it doesn't need to chunk documents that are never accessed.

The trade-offs is that it adds latency on first access (chunking happens in real-time), and requires more complex infrastructure to manage.

IMHO, the flexibility is worth it. Pre-chunking forces you to make decisions before you know what users will actually ask. Post-chunking can adapt to the actual queries your system receives.

Check out the blog on Elysia for more: https://t.co/8bszzvLMC7
Our context engineering ebook also goes into chunking strategies in depth: https://t.co/0swiDXUoOY

[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.

[Dhanian 🗯️ @e_opore]

ENCODER–DECODER LLMS

✓ Encoder–Decoder models (also called sequence-to-sequence models) process input text in two stages: the encoder understands the input, and the decoder generates meaningful output based on that understanding.

WHAT ENCODER–DECODER MODELS ARE

→ Two-part Transformer architecture: Encoder + Decoder.
→ Encoder converts the input into rich hidden representations.
→ Decoder uses these representations to produce output step-by-step.
→ Ideal for tasks where input and output differ in length or structure (e.g., translation).

HOW THE ENCODER WORKS

✓ Goal: Understand and compress the input.

→ Input text → tokenized → embedded into vectors.
→ Positional encodings added to preserve order.
→ Multi-Head Self-Attention layers capture relationships between all input tokens.
→ Feed-forward networks refine the meaning.
→ Output: a contextual representation of the entire input sequence.

HOW THE DECODER WORKS

✓ Goal: Generate text using both past output and encoder knowledge.

→ Takes previous output tokens (or start token).
→ Uses Masked Self-Attention to look only at earlier tokens → prevents future leakage.
→ Uses Cross-Attention to attend to encoder outputs.
→ Feed-forward layers refine predictions.
→ Linear + Softmax → produces next token.

WHY ENC0DER–DECODER LLMS ARE POWERFUL

→ They separate understanding (encoder) from generation (decoder).
→ Excellent for tasks requiring deep semantic transformation:
→ → Translation
→ → Summarization
→ → Question Answering
→ → Dialogue systems
→ → Text-to-SQL and other structured outputs
→ Training becomes stable because each module specializes.

ENCODER–DECODER VS DECODER-ONLY MODELS

✓ Encoder–Decoder Models
→ Strong comprehension + strong generation.
→ Better for structured transformations.
→ Heavier architecture but more accurate for many NLP tasks.

✓ Decoder-Only Models
→ Good for free-form text generation.
→ Simpler and easier to scale.
→ Less ideal for tasks needing precise alignment between input and output.

HOW INFORMATION FLOWS THROUGH THE MODEL

→ Input tokens → Encoder → Hidden representation
→ Decoder reads:
→ → Past generated tokens (via masked attention)
→ → Encoder output (via cross-attention)
→ Final output tokens → combined into full generated sequence.

REAL-WORLD ENCODER–DECODER MODELS

→ T5 (Text-To-Text Transfer Transformer)
→ BART
→ Pegasus
→ FLAN-T5
→ MarianMT
→ Original Transformer (Vaswani et al., 2017) was encoder–decoder.

These models power large-scale translation systems, summarizers, Q/A bots, and many enterprise NLP solutions.

📘 Grab the LLMS Ebook:
https://t.co/DBXPEOcHrI

[Avi Chawla @_avichawla]

Stanford researchers built a new prompting technique!

By adding ~20 words to a prompt, it:

- boosts LLM's creativity by 1.6-2x
- raises human-rated diversity by 25.7%
- beats fine-tuned model without any retraining
- restores 66.8% of LLM's lost creativity after alignment

Post-training alignment methods, such as RLHF, are designed to make LLMs helpful and safe.

However, these methods unintentionally cause a significant drop in output diversity (called mode collapse).

When an LLM collapses to a mode, it starts favoring a narrow set of predictable or stereotypical responses over other outputs.

This happens because the human preference data used to train the LLM has a hidden flaw called typicality bias.

Here’s how this happens:
- Annotators rate different responses from an LLM, and later, the LLM is trained using a reward model to mimic these human preferences.
- However, annotators naturally tend to favor answers that are more familiar, easy to read, and predictable. This is the typicality bias.

So even if a new, creative answer is just as good, the human’s preference often leans toward the common one.

Due to this, the reward model boosts responses that the original (pre-aligned) model already considered likely.

This aggressively sharpens the LLM’s probability distribution, collapsing the model’s creative output to one or two dominant, highly predictable responses.

That said, it is not an irreversible effect, and the LLM still has two personalities after alignment:
- The original model that learned the rich possibilities during pre-training.
- The safety-focused, post-aligned model.

Verbalized sampling (VS) solves this.

It is a training-free prompting strategy introduced to circumvent mode collapse and recover the diverse distribution learned during pre-training.

The core idea of verbalized sampling is that the prompt itself acts like a mental switch.

When you directly prompt “Tell me a joke”, the aligned personality immediately takes over and outputs the most reinforced answer.

But in verbalized sampling, you prompt it with “Generate 5 responses with their corresponding probabilities. Tell me a joke.”

In this case, the prompt does not request an instance, but a distribution.

This causes the aligned model to talk about its full knowledge and is forced to utilize the diverse distribution it learned during pre-training.

This way, the model taps into the broader, diverse set of ideas, which comes from the rich distribution that still exists inside its core pre-trained weights.

Verbalized sampling significantly enhances diversity by 1.6–2.1x over direct prompting, while maintaining or improving quality.

Variants like verbalized sampling-based CoT (Chain-of-Thought) and verbalized sampling-based Multi improve generation diversity even further.

I have shared the paper in the replies!

👉 Over to you: What other methods can be used to improve LLM diversity?

[Victoria Slocum @victorialslocum]

Your AI agent is forgetting things.

Not because the model is bad, but because you're treating memory like storage instead of an active system.

Without memory, an LLM is just a powerful but stateless text processor - it responds to one query at a time with no sense of history. Memory is what transforms these models into something that feels way more dynamic and capable of holding onto context, learning from the past, and adapting to new inputs.

Andrej Karpathy gave a really good analogy: think of an LLM's context window as a computer's RAM and the model itself as the CPU. The context window is the agent's active consciousness, where all its "working thoughts" are held. But just like a laptop with too many browser tabs open, this RAM can fill up fast.

So how do we build robust agent memory? We need to think in layers, blending different types of memory:

1️⃣ 𝗦𝗵𝗼𝗿𝘁-𝗧𝗲𝗿𝗺 𝗠𝗲𝗺𝗼𝗿𝘆: The immediate context window
This is your agent's active reasoning space - the current conversation, task state, and immediate thoughts. It's fast but limited by token constraints. Think of it as the agent's "right now" awareness.

2️⃣ 𝗟𝗼𝗻𝗴-𝗧𝗲𝗿𝗺 𝗠𝗲𝗺𝗼𝗿𝘆: Persistent external storage
This moves past the context window, storing information externally (often in vector databases) for quick retrieval when needed. It can hold different types of info:
• Episodic memory: specific past events and interactions
• Semantic memory: general knowledge and domain facts
• Procedural memory: learned routines and successful workflows

This is commonly powered by RAG, where the agent queries an external knowledge base to pull in relevant information.

3️⃣ 𝗪𝗼𝗿𝗸𝗶𝗻𝗴 𝗠𝗲𝗺𝗼𝗿𝘆: A temporary task-specific scratchpad
This is the in-between layer - a temporary holding area for multi-step tasks. For example, if an agent is booking a flight to Tokyo, its working memory might hold the destination, dates, budget, and intermediate results (like "found 12 flights, top candidates are JAL005 and ANA106") until the task is complete, without cluttering the main context window.

Most systems I've seen use a hybrid approach, using short-term memory for speed with long-term memory for depth, plus working memory for complex tasks.

Effective memory is less about how much you can store and more about 𝗵𝗼𝘄 𝘄𝗲𝗹𝗹 𝘆𝗼𝘂 𝗰𝗮𝗻 𝗿𝗲𝘁𝗿𝗶𝗲𝘃𝗲 𝘁𝗵𝗲 𝗿𝗶𝗴𝗵𝘁 𝗶𝗻𝗳𝗼𝗿𝗺𝗮𝘁𝗶𝗼𝗻 𝗮𝘁 𝘁𝗵𝗲 𝗿𝗶𝗴𝗵𝘁 𝘁𝗶𝗺𝗲. Advanced techniques like reranking and iterative retrieval can dramatically improve the quality of what gets pulled back into context.

The architecture you choose depends entirely on your use case. A customer service bot needs strong episodic memory to recall user history, while an agent analyzing financial reports needs robust semantic memory filled with domain knowledge.

Learn more in our context engineering ebook: https://t.co/gkGf04Hv32

[Aurimas Griciūnas @Aurimas_Gr]

You must know these 𝗔𝗴𝗲𝗻𝘁𝗶𝗰 𝗦𝘆𝘀𝘁𝗲𝗺 𝗪𝗼𝗿𝗸𝗳𝗹𝗼𝘄 𝗣𝗮𝘁𝘁𝗲𝗿𝗻𝘀 as an 𝗔𝗜 𝗘𝗻𝗴𝗶𝗻𝗲𝗲𝗿.

If you are building Agentic Systems in an Enterprise setting you will soon discover that the simplest workflow patterns work the best and bring the most business value.

At the end of last year Anthropic did a great job summarising the top patterns for these workflows and they still hold strong.

Let’s explore what they are and where each can be useful:

𝟭. 𝗣𝗿𝗼𝗺𝗽𝘁 𝗖𝗵𝗮𝗶𝗻𝗶𝗻𝗴: This pattern decomposes a complex task and tries to solve it in manageable pieces by chaining them together. Output of one LLM call becomes an output to another.

✅ In most cases such decomposition results in higher accuracy with sacrifice for latency.
ℹ️ In heavy production use cases Prompt Chaining would be combined with following patterns, a pattern replace an LLM Call node in Prompt Chaining pattern.

𝟮. 𝗥𝗼𝘂𝘁𝗶𝗻𝗴: In this pattern, the input is classified into multiple potential paths and the appropriate is taken.

✅ Useful when the workflow is complex and specific topology paths could be more efficiently solved by a specialized workflow.
ℹ️ Example: Agentic Chatbot - should I answer the question with RAG or should I perform some actions that a user has prompted for?

𝟯. 𝗣𝗮𝗿𝗮𝗹𝗹𝗲𝗹𝗶𝘇𝗮𝘁𝗶𝗼𝗻: Initial input is split into multiple queries to be passed to the LLM, then the answers are aggregated to produce the final answer.

✅ Useful when speed is important and multiple inputs can be processed in parallel without needing to wait for other outputs. Also, when additional accuracy is required.
ℹ️ Example 1: Query rewrite in Agentic RAG to produce multiple different queries for majority voting. Improves accuracy.
ℹ️ Example 2: Multiple items are extracted from an invoice, all of them can be processed further in parallel for better speed.

𝟰. 𝗢𝗿𝗰𝗵𝗲𝘀𝘁𝗿𝗮𝘁𝗼𝗿: An orchestrator LLM dynamically breaks down tasks and delegates to other LLMs or sub-workflows.

✅ Useful when the system is complex and there is no clear hardcoded topology path to achieve the final result.
ℹ️ Example: Choice of datasets to be used in Agentic RAG.

𝟱. 𝗘𝘃𝗮𝗹𝘂𝗮𝘁𝗼𝗿-𝗼𝗽𝘁𝗶𝗺𝗶𝘇𝗲𝗿: Generator LLM produces a result then Evaluator LLM evaluates it and provides feedback for further improvement if necessary.

✅ Useful for tasks that require continuous refinement.
ℹ️ Example: Deep Research Agent workflow when refinement of a report paragraph via continuous web search is required.

𝗧𝗶𝗽𝘀:

❗️ Before going for full fledged Agents you should always try to solve a problem with simpler Workflows described in the article.

What are the most complex workflows you have deployed to production? Let me know in the comments 👇

#LLM #AI #MachineLearning

[Rahul Rajan @RahulR9191]

@python_spaces Ai Agents

[Python Developer @PythonDvz]

🚀 8 Types of AI Agents You Should Know

AI agents are evolving beyond just text generation. Different architectures are being designed to specialize in reasoning, perception, action, and abstraction. Here’s a quick breakdown:

1️⃣ GPTs – general-purpose text generators, great for fluency and versatility.
2️⃣ MoE (Mixture of Experts) – route tasks to specialized subnetworks for efficiency.
3️⃣ Large Reasoning Models – optimized for multi-step logical reasoning.
4️⃣ Vision-Language Models – bridge perception and language for multimodal tasks.
5️⃣ Small Language Models – lightweight, cost-efficient agents for edge deployment.
6️⃣ Large Action Models – built to execute code, call APIs, and perform tasks autonomously.
7️⃣ Hierarchical Language Models – break problems into sub-tasks, enabling long-horizon planning.
8️⃣ Large Concept Models – capture abstract, high-level knowledge for generalization.

🔍 What this really shows is that “AI agents” are no longer a monolithic idea. They’re evolving into a system of complementary architectures—each optimized for a different layer of intelligence.

Which of these excites you the most?

[Turing Post @TheTuringPost]

7+ main precision formats used in AI

▪️ FP32
▪️ FP16
▪️ BF16
▪️ FP8 (E4M3 / E5M2)
▪️ FP4
▪️ INT8/INT4
▪️ 2-bit (ternary/binary quantization)

General trend: higher precision for training, lower precision for inference.

Save the list and learn more about these formats here: https://t.co/w77l2CuIEa