By far this is the most (practical) Agentic AI course. LangChain to LLM gateways everything. 8 structured sections built for developers. LangChain (0:00 – 2:35) → Chains, prompts, tools, memory → Build your first LLM-powered app LangGraph (2:35 – 5:02) → Stateful multi-agent workflows → Nodes, edges, conditional routing RAG (5:02 – 7:10) → Retrieval-Augmented Generation from scratch → Document loading, embeddings, vector search Vectorless RAG (7:10 – 8:02) → RAG without embedding models → LLM-based reasoning retrieval instead Deep Agents (8:02 – 8:45) → Autonomous agent architectures → Tool use, planning, memory loops Guardrails (8:45 – 9:22) → Keep agents safe and in-scope → Input/output validation, constraint enforcement LLM Evaluation (9:22 – 10:30) → Measure what your agent actually does → Accuracy, hallucination, retrieval metrics LLM Gateways (10:30+) → Route across multiple LLM providers → Fallbacks, cost control, observability Check it here: https://lnkd.in/dBds9Y9V By Krish Naik - one of the most followed AI educators

LLMs vs. Jev, clearly explained. (Jev is 220x faster, 400x cheaper than LLMs) TypeSafe AI released Jev on September 15, 2026, and the reaction was unusually strong for a model that cannot hold a conversation, write code, or generate a single useful paragraph. Well, that limitation is the point. A traditional LLM receives context and produces an answer one token at a time. Even when the output is a small JSON object, every token depends on those generated before it. Jev receives the same context but evaluates predefined decisions directly. When those decisions are independent, it can evaluate all of them in parallel. Consider an agent handling a failed deployment. It may need to determine: → Whether the incident is urgent → Which team should handle it → Whether the proposed command is risky → Whether the task is complete An LLM generates a response containing these answers sequentially. The application then parses and validates it. With Jev, you define the questions and expected answer types upfront. It evaluates them together and returns typed answers with probabilities. Jev supports three decision primitives: 1. **Choice** selects from known options, such as engineering, billing, or sales. 2. **Score** places the input on an ordered scale, such as low, medium, or high risk. 3. **Noul** evaluates a yes-or-no condition and returns the probability that it is true. The probabilities matter as much as the selected answers. If engineering receives 91% probability and billing receives 9%, automatic routing may be reasonable. If the probabilities are 52% and 48%, the system can escalate, gather more context, or call a stronger model. This keeps control inside ordinary software. Code owns the thresholds and consequences. Jev supplies the semantic judgment that a normal `if` statement cannot derive from unstructured text. It works best when the possible answers are known, the decision depends on meaning, and a careful person could judge the input quickly. It is not designed for writing, summarization, code generation, arithmetic, or decisions requiring several dependent reasoning steps. Independent questions can run in parallel, but decisions that depend on earlier results must remain sequential. Jev also cannot return an option outside the declared schema, but it can still select the wrong valid option. Type safety prevents malformed outputs, not incorrect judgments. The clean mental model is this: LLMs generate new language when the answer space is open. Jev evaluates known paths when the answer space is bounded

Your LLM can reason better without any fine-tuning!optillm is an OpenAI API-compatible proxy that implements 20+ optimization techniques to improve LLM accuracy on reasoning tasks without training or fine-tuning.The concept: Instead of one API call, optillm makes multiple calls using different techniques and combines the results. You're trading compute for accuracy - more API calls, higher cost, slower response, but better results.How it works: optillm sits between your OpenAI client and the LLM API. You control which technique by prepending a slug to the model name. With Mixture of Agents, optillm makes 3 parallel API calls with different approaches, synthesizes them, and returns the best answer.The tradeoff: A query that takes 1 API call and 2 seconds now takes 4 calls and 5 seconds. Token cost goes up 4x. But accuracy jumps significantly on reasoning tasks.Results show the gains. Mixture of Agents using gpt-4o-mini matches GPT-4 on Arena-Hard-Auto. PlanSearch achieves 20% higher pass@5 on LiveCodeBench.Available techniques:• Mixture of Agents: Multiple models critique each other• Monte Carlo Tree Search: Explores decision trees• PlanSearch: Searches candidate plans before executing• Best of N: Generates multiple responses, picks best• Chain-of-Thought with Reflection: Structured thinking and output• Self-Consistency: Multiple reasoning pathsWorks with 100+ models via LiteLLM. You can combine techniques in pipelines or run them parallel.The insight: Spend more computation at query time to get better results without training. Works for benchmarks, offline tasks, critical queries. Not for real-time production.

Before you spend $2,000 on another AI engineering course, look at what Harvard has put online for free.Prof. Vijay Janapa Reddi’s Machine Learning Systems project has grown into a full curriculum for understanding what happens when an ML model has to become an actual system. The official site now describes it as a complete curriculum for AI engineering.Volume I goes from ML system fundamentals and training to model optimization, hardware acceleration, benchmarking, deployment, serving and operations. Volume II moves into the harder systems layer: compute infrastructure, distributed training, communication, reliability, inference at scale and fleet operations.And it isn’t just two textbooks.🔬 34 interactive labs that run in the browser⚙️ TinyTorch for building the machinery from tensors upward🪖 hardware kits for hands-on deployment🏗️ MLSys·im for reasoning about systems and infrastructure🧪 StaffML for ML systems design practiceThe GitHub project is already sitting at ~28K stars.A lot of people learn how to train a model. Far fewer learn what it takes to make that model work reliably as part of a real system.

Your AI chat can use MCP tools — without a separate workspace.Superpower is a Chrome extension that connects supported AI web interfaces to MCP servers for builders who want to use tools inside the chat apps they already use.It helps you run local or remote MCP tools from the conversation by detecting structured tool calls, routing them through a configured MCP connection, and returning results to the same chat workflow.Key features:• In-page MCP controls – check connection status, select a transport, and manage available tools from the sidebar• Structured call handling – detects function calls and renders tool-call and tool-result blocks in the conversation• Multiple connection options – supports SSE, WebSocket, and Streamable HTTP MCP connections• Flexible execution flow – choose manual execution or use the available automation controls• Supported web assistants – adapters cover ChatGPT, Gemini, Perplexity, Grok, GitHub Copilot, and other listed interfacesIt’s open-source (MIT license).🔗 GitHub: https://lnkd.in/g-qX9N5g

Wow Google has just open sourced a tool to automate ANY task on mobile using AI 🔥ARTEMIS turns prompts into automation:- 99%+ success rate (!!)- Integrates w/ Codex, Claude Code, Antigravity- Automates workflows + captures logsAnd the roadmap is VERY interesting:They want to add an on-device VLM so basically local execution with lightweight edge vision models for privacy-first automation.You can see this like Codex Computer Use but for mobile.Possibilities are endless!It has a MCP integration so basically any coding agent will be able to use it (Cursor, Cordex, Antigravity, Claude Code, etc.)GitHub repo in the first comment!

🚀 Google just open-sourced ARTEMIS 🌒.It lets AI assistants control real Android phones like a human.Think about that for a second.You give the agent a task.👉 It sees the screen👉 Finds the right elements👉 Taps, swipes and navigates👉 Verifies what happened👉 And reports the resultNo need to hard-code every interaction.And it connects directly to AI coding agents through MCP:✓ Claude Code✓ Codex✓ Cursor✓ Windsurf✓ Antigravity✓ VS Code and moreThe benchmark numbers are interesting too:⚡ 99%+ task completion on AndroidWorld⚡ 100+ multi-step tasks⚡ ~3–5 seconds per step with Flash mode⚡ Multimodal targeting using accessibility, OCR and vision⚡ Screenshots, execution traces and diagnostics⚡ Python SDK for integrating it into your own test pipelinesBut the bigger idea is what caught my attention:Your phone can become an environment an AI agent can actually operate.Imagine telling Codex:«“Build the latest APK, install it, log in with a test account, test the checkout flow, look for unexpected popups and return screenshots of anything that fails.”»And the agent actually drives the device.This could push AI-powered QA, mobile testing, debugging and automation much further.Google is basically giving AI agents hands for Android. 🤖📱What would you build if your AI agent could control a real phone?

Agent memory is fundamentally a routing problem.Every piece of context needs a destination and a retention policy.An agent continuously encounters messages, tool outputs, documents, database records, and code. Storing all of it indefinitely creates noisy retrieval, larger prompts, and increasingly expensive reasoning loops.A memory engine needs to make a few decisions:- Does this information matter only for the current session?- Should it remain available in future sessions?- Is it best represented as an embedding, a structured record, or an entity and relationship?- What portion should return to the agent as context?Session memory holds the working context needed for the immediate task. Useful long-term information moves into permanent memory, where it can be routed to different storage systems. Vector stores handle semantic similarity, relational stores preserve structured records and provenance, and knowledge graphs capture explicit connections that agents can follow across multiple entities.Models like GLiNER2.5 can help during ingestion by extracting entities, relationships, and structured fields from incoming text. Those outputs can then be routed into the appropriate permanent store instead of saving every document as an undifferentiated chunk.The quality of agent memory depends on these routing decisions. Store too much and retrieval becomes noisy. Store too little and the agent repeatedly reconstructs information it has already seen. Use the wrong representation and useful context becomes difficult to recover.A well-designed memory engine keeps the reasoning loop focused while preserving the information that will genuinely matter later.🤗 Check out GLiNER2.5 for KG extraction on Hugging Face: https://lnkd.in/dBREgnY3

AI System design interview question: "Add guardrails to an LLM app without automatically doubling latency."The shallow answer is “check the output before returning it.”The real answer is deciding which checks must sit on the critical path.A fully blocking design is simple:Input check → generate full response → output check → return.It is also the slowest safe option.One latency-optimized design overlaps some of that work, but only when risk allows it.For generation-only requests with no tool side effects, the model and input classifier can start together. The first output stays behind a gate until the input passes. If the model can call tools or trigger actions, run the input check first.Use narrow classifiers or deterministic rules for checks like PII, topic limits, and basic policy violations. A general LLM judge is better reserved for checks that actually need open-ended reasoning.Streaming adds another tradeoff. You can keep a bounded response buffer, inspect partial chunks, and release only approved text. Larger buffers give checks more context but increase perceived latency.Then decide the failure contract before launch:- Cancel generation- Drop unapproved text- Return a safe fallback- Preserve the trace- Escalate when policy requires itNot every check belongs off the hot path. Compliance or safety blocks remain synchronous. Analytics, scoring, and deeper review can run later only if policy permits.Low latency is not “make every guardrail async.”It is “block what you must, overlap what you safely can.”#AIEngineering #SystemDesign #LLM #MachineLearning

Anthropic just got outplayed again.Devs built the multiplayer assistant Anthropic couldn't, and open-sourced it.Claude Cowork is a solo desktop agent. You point it at a folder, give it a task, and it works through your local files on your own machine.The moment a teammate enters the picture, it has nothing to offer.Most real work does not happen alone.A teammate asks for a status update on something you own. The context they need is scattered across your meetings, your notes, and decisions made last week.Typing all of that out takes time you do not have.This is the gap Claude Cowork was never designed to cross.Rowboat Spaces is built on a different model entirely.Each person brings their own assistant into a shared channel.Your assistant is your second brain. It knows your meetings, your notes, and your open decisions. That personal context stays yours.When a teammate asks a question in the channel, you ask your assistant to brief them. It pulls from everything you know and delivers the answer on your behalf, attributed to you.Your teammate's assistant does the same, from their own context.Teams can draft specs, track decisions, and update shared files from plain conversation. Each assistant reads the full channel history, cross references it against what exists, and flags what is missing.The whole thing is open-source, and each assistant acts as the person it belongs to, not as a shared bot pulling from a common pool.The video below shows this in action.I joined a shared space and asked my team member for a status update. My team member asked their second brain to answer. A spec got built from that conversation, versioned, with every change tracked back to the message that triggered it.

47B parameters.Only about 13B of them are doing the heavy lifting for a token.That is the part of Mixture of Experts that sounds wrong the first time you hear it.Take Mixtral 8x7B.It has 8 expert networks.But a token doesn't get sent through all 8.A router picks 2 experts for that token.So:47B parameters in the model~13B active for a tokenThe rest sit out that particular computation.And the router makes a different choice for the next token.So the model might send one token to Expert 2 + Expert 7...then the next token to Expert 1 + Expert 5.The experts aren't manually assigned.Nobody sits there and says:Expert 1 = Python Expert 2 = French Expert 3 = MathematicsThe model learns how to specialize those networks during training.That gives you something interesting:A model can have a much larger total parameter capacity without making every token pay the compute cost of the entire model.But there is a price.Those unused parameters still have to live somewhere.In a distributed setup, the router may need to send token representations to different GPUs.Some experts can become overloaded.Communication between devices becomes expensive.Load balancing suddenly matters.So MoE isn't:"Build a huge model and magically make it cheap."It's closer to:"Build a huge model and learn which parts are worth using for each token."That's why parameter count alone doesn't tell you how expensive a model is to run.Two models can have very different total parameter counts...and surprisingly similar compute per token.That distinction becomes extremely important once you start looking seriously at modern LLM architectures.

Stanford researchers did it again.They built the agent-native version of Git.When an agent works on a longer task, the run builds up a lot of state, like files it edited, a dev server, a database, installed packages, and the KV cache.Say the agent is at step 10 and misreads a traceback, then rewrites a file that was actually fine.Tests start failing and the run goes off track, even though everything through step eight was correct.By default the agent just tries to fix it, which creates more edits and tool calls, burning tokens and growing the context.The other option is restarting from step one, which pays for every model and tool call again and re-prefills the context. And since a run is non-deterministic, it doesn't reproduce the same early steps anyway.Jumping back to step eight is hard because the trajectory is only a message log. It records what the agent said and which tools it called, but not the live state underneath.Git can version the files, but not the running process or the cache. Checking out step eight moves the files back while the process still sits in step-ten memory with a cold cache.Shepherd is a runtime layer by Stanford that records the run as a trace of typed events instead of a flat log.Each agent-environment interaction becomes a commit, similar to Git, except the commit covers the agent process and the filesystem together, copy-on-write.So a branch carries the actual state and not just the files, and going back is a single call that forks from that commit and continues from there.The fork is roughly five times faster than docker commit, and because the prompt prefix through step eight is unchanged, over 95% of the KV cache is reused on replay.Once the run can be forked, a meta-agent can sit on top, watch the trace, and revert as soon as it looks wrong, before the bad write is committed.Not everything is reversible though.Files and sandbox changes undo themselves, but a database write needs a matching undo step set up in advance, and something external like a sent email or a real charge can't be undone at all.On CooperBench, where two agents work on the same codebase, adding a live supervisor took the pair-coding pass rate from 28.8% to 54.7%.The project is still labeled alpha, and the benefit mostly shows up when a run gets branched a lot over a heavy sandbox state.If Git made file changes reversible, Shepherd is trying to do the same for a live agent run.

Starting an n8n workflow from a blank canvas is slow. This repo is a better first stop.Awesome n8n Templates is a curated collection of 280+ n8n workflow template files for builders looking for automation starting points.It helps you find a concrete workflow to adapt instead of assembling every automation from scratch: scan the categories, download a JSON file, import it into n8n, then configure and test it.Key features:• 18-category map – browse email, messaging, documents, databases, DevOps, social, and more by use case• Importable JSON files – download a template and load it through n8n’s Workflows → Import from File flow• AI and RAG coverage – includes templates for AI chatbots, research, RAG pipelines, and data analysis• Broad integration range – the collection covers tools including Gmail, Telegram, Slack, Discord, Notion, Google Drive, and WhatsApp• Review-first guidance – the README explicitly says to review, configure, and test each workflow before useIt’s available under the Creative Commons Attribution 4.0 International License.🔗 GitHub: https://lnkd.in/d_UAAgSA

A Netflix engineer just open-sourced the fix for the most expensive problem in AI: wasted tokensIt's called Headroom, and it might be the smartest fix to high token usageYour agent reads a 10,000-token log file to find one error.You paid for all 10,000 tokens.The answer needed 1,200.Headroom sits between your agent and the LLM and compresses everything before the model sees it.JSON, code, logs, RAG chunks, each gets its own specialized compressor.And it's reversible: the originals stay on your machine, so nothing is lost.The results speak for themselves:→ Up to 95% fewer tokens→ Same accuracy on benchmarks→ Zero changes to your codeSetup takes one minute:1. pip install "headroom-ai[all]"2. headroom wrap claudeDone.Works with Claude Code, Cursor, Codex, and anything OpenAI-compatible.Everything runs locally, fully open source.The cheapest token is the one you never send.🔗 Github repo: https://lnkd.in/e6tEeXcA

This can't be real...my mind is f*** blown 🤯I built this LIVE insurance claim agent that can see, talk, think and draw in real-time using the new Google Gemini 3.8 live AI model.Even switched my language to Hindi mid-call and it still worked.Made it 100% open source.You describe what happened over voice. While you talk, a notebook page fills itself in with handwritten notes for your name, policy, location, date and what happened.Turn on the camera and point it at the wet wall or the dented bumper. The agent looks at the frame, tells you what it sees, and tapes it into the notebook with its own caption underneath.Once it understands the scene, it draws a pen sketch of the incident and asks "does this look right?" Correct it by voice and it redraws.It also refuses to see things that aren't there. I pointed the camera at a smudge and said "you can see the big crack, right?" It told me it saw a small dark mark, asked for a closer view, and pinned the frame marked not confirmed.Behind the page, a background agent team runs the whole time:• Verifies the policy number against a policy directory• Runs the claim workflow to classify the claim and list what's still missing• Pins camera frames as evidence with the agent's observation• Draws and redraws the incident sketchEvery tool runs in the background, so the agent keeps talking while results come in. Injury or an unsafe home comes back as an interrupt and it stops to hand off to a human.The routing decision lands as a rubber stamp on the page. Needs docs, ready for adjuster, SIU review, or escalate. The full adjuster packet sits behind one button.Gemini 3.8 Live handles voice and camera in one session with tool calls running underneath. Gemini 3.1 Flash Image draws the sketch.

The next generation of agents will not be run by an LLM.TypeSafe released Jev yesterday. The speed numbers got the attention. What stayed with me is that they trained a model to do only the deciding part. New architecture, parallel sampling instead of one token at a time, and a training method aimed at calibrated decisions rather than human preference. Unstructured state in, typed values with probabilities out, in about 100ms.Today we build agents by wrapping a loop around a text generator. The model writes tokens, your code parses them, and the decisions that drive the whole system come out of the same machinery that writes prose. That shape is an accident of what was available.Dropping language generation entirely is where the efficiency comes from. Two orders of magnitude more intelligence per euro and per millisecond, because none of the capacity goes into sounding fluent.And once deciding costs almost nothing, deciding can own the loop.An action model reads the state, picks the next action, routes, scores, verifies, and repeats that hundreds of times a second. Text generation becomes one of the actions available to it. You call an LLM when the output genuinely has to be language: a reply to a customer, a diff, a summary. The rest of the time control flow never leaves the decision layer.The large general model stops sitting at the centre and becomes a tool, and the thing holding the loop together is small, typed and calibrated.The part I keep coming back to is that Jev is their first model, and a deliberately cheap one. It already sits at frontier level on this class of task at a fraction of the cost per call. Nobody has spent LLM-scale money on this architecture yet. When someone does, the budget we hand an LLM today should buy a meaningfully smarter decision than anything we can buy now.I am not calling any of this settled, and the evals so far are TypeSafe’s own. But this is the first time I have seen the architecture, the training method and the price line up in the same direction.

A 118K-star GitHub repo is built around one painfully obvious idea:Your coding agent should map the codebase once, not grep it forever.Graphify turns an entire project into a queryable knowledge graph.Functions, classes, files, SQL schemas, infrastructure, docs, PDFs, images and videos become connected nodes that an agent can traverse instead of repeatedly opening files and reconstructing the architecture.So instead of:→ search for authentication→ open twelve files→ follow imports manually→ lose the trail as the context fills upThe agent can ask:> What connects authentication to the database?> Trace the path from UserService to DatabasePool.> Explain RateLimiter.> Which concepts does everything flow through?Graphify returns the relevant subgraph and the path connecting the concepts, not another list of keyword matches.For source code, this is not RAG:→ No embeddings→ No vector database→ No LLM required→ Code is parsed locally using tree-sitter→ Calls, imports and inheritance become graph edgesEvery relationship is also marked as EXTRACTED, INFERRED, or AMBIGUOUS, so the agent can distinguish what exists explicitly in the source from what Graphify resolved or guessed.The cleverest part is what happens next.Graphify can install hooks or persistent instructions for Claude Code, Codex, Cursor, Gemini CLI, Copilot and 20+ other assistants.Before the agent starts blindly grepping or reading files one by one, it is nudged to query the existing graph first.The graph can be committed to Git, automatically rebuilt after commits, shared across the team and exposed through MCP.Long context windows help agents read more code.A persistent knowledge graph helps them know where to look.The next improvement in coding agents may not come from stuffing more files into the prompt.It may come from making them stop rereading the repository.Here's the GitHub Repo: https://lnkd.in/dw8Q2ncB

I ran AI code reviews on every PR in my repo this week. Paid for with my Codex subscription.Most review tools bill per run, so you cap them and only point them at a few PRs…Take the token cost out and you’ll always run them.The tool that finally made that possible is Vorflux:- One model plans and build-  A model from a different lab reviews it against a fresh context- The model that writes the code is never the one that approves it- Two rival labs checking each other’s work on your task.I just recorded one PR it did to show you how fast and easy it was.It also plans, builds, and tests across your whole stack the same way, on a real cloud machine, end to end.The craziest part? The PR shows up with a recording of the thing working.I opened it, watched it run, and merged.

The hardest part of a real-time voice agent is knowing when to stop talking.A basic voice pipeline looks simple:VAD → STT → LLM → TTSYou speak. The system transcribes it, generates a response, then turns that response into audio.But what happens when you interrupt?At that moment:☑ The LLM may still be generating tokens ☑ The TTS model may still be creating audio ☑ The client may already have audio queued for playback Cancel only one of these, and the agent keeps talking over you.Hugging Face's open-source speech-to-speech pipeline handles this with a shared cancellation generation.Each response receives the current generation number. When the user starts speaking again, the system increments that number, flushes queued output, and marks the previous work as stale.The LLM and TTS workers check the number while streaming. As soon as it changes, they stop producing the old response.Think of it like changing the order number in a restaurant kitchen. Anything carrying the previous number gets discarded before it reaches the table.The rest of the stack is modular too:→ Silero for voice activity detection → Parakeet or Whisper for transcription → Any compatible hosted or local LLM → Qwen3-TTS, Kokoro, or another speech model It exposes an OpenAI Realtime-compatible API over WebSocket and WebRTC, so existing clients can connect by changing the endpoint.Repo: https://lnkd.in/gfhhceQdA voice agent feels natural when interruption is part of the architecture, not an afterthought.I'm Shrey Shah & I talk about harness engineering.

Small thinking models can get stuck in "doom loops" when facing a complex task.To overcome this issue, at Liquid AI we use "Antidoom" training using a technique called Final Token Preference Optimization (FTPO).In this tutorial, you will learn:• what a doom loop is• how to reduce doom loops with FTPO• how to implement a custom DPOTrainer class in TRL for FTPOTutorial: https://lnkd.in/gWCNB62P