GenAI Interviewer Question Series Interview: Two retrieved documents contain different answers to the same question. One is from last year, while the other was updated yesterday. Question: How would you design the retrieval and ranking pipeline to identify the authoritative and most recent information? Explanation: Metadata Filtering: Store document version, effective date, source, department, and authority level as metadata during ingestion. Retrieval: Use hybrid search to retrieve semantically relevant documents, then apply metadata filters where appropriate. Authority Ranking: Assign higher ranking to trusted sources, such as official policies, over drafts or user-generated documents. Recency Ranking: Boost documents with newer effective dates, not simply upload timestamps. Reranking: Use a cross-encoder/reranker combining relevance, authority, version, and freshness signals. Conflict Detection: If two high-confidence sources still conflict, trigger a conflict-resolution step rather than blindly selecting one. Generation: Instruct the LLM to prioritize the authoritative, latest effective document and provide citations. Evaluation: Measure retrieval accuracy, freshness, source correctness, and conflict-resolution accuracy. _________________________________________________________________________ Preparing for an ML or AI interview or Looking for Transition in AI? Check out the resource below, it covers key concepts with 1000 interview question Answers, Roadmap, Projects and practical topics to help you prepare with confidence. 🔗 Link: https://lnkd.in/dez6Ji7E

Production AI is not "pick a model, write a prompt, ship." Here’s what’s actually inside an AI engineer’s brain before production. The model is only one part of the system. The hard part is making the whole thing reliable, affordable, and useful for a real user problem. Here’s the mental checklist: → User problem: What exact job is the user trying to get done? If this is fuzzy, everything after this is optimization around the wrong target. → Retrieval: Do we need RAG at all? If yes, what should be retrieved, how fresh should it be, and what happens when retrieval returns weak context? → Agent behavior: Should this be a simple prompt flow or a real agent? More tool use means more power... and more ways to fail. → Latency: How long can the user reasonably wait? A great answer in 18 seconds is often worse than a good answer in 3. → Token cost: What does each request cost at scale? Long context, multiple retries, and agent loops quietly turn into a budget problem. → Evals: How will we know the system is good? Not just "it worked in the demo" but task success, answer quality, safety, and consistency. → Retries: What fails transiently, and what fails permanently? You need different handling for timeout, empty retrieval, malformed output, and tool failure. → Rate limits: What happens under real traffic? One happy path test says nothing about production concurrency. → Logging: Can we trace what happened for one bad response? Prompt, retrieved chunks, tool calls, model output, latency, and final decision should all be visible. → Structured output: What happens when the model breaks your JSON? Because eventually it will. → Guardrails: What is the model allowed to say, do, or trigger? Especially when answers can affect money, data, or customer trust. The key takeaway: Production AI is not prompt engineering. It is systems engineering around a probabilistic model. And the best teams keep coming back to one question: Does this actually solve the user’s problem... better, faster, or cheaper? --- ♻️ Repost if you found it helpful! ➕ We often discuss real-world AI/ML here 👇 ➕ Join 53,500+ AI/ML builders here: https://lnkd.in/ds_SzEUH

800ms of voice-agent latency can come from distance, not the model.A voice agent can have a fast LLM and still feel painfully slow.Here’s where the hidden latency and cost often come from:1️⃣ Distance → LatencyUser in Mumbai→ Audio travels to the US→ STT processes it→ LLM responds→ TTS generates audio→ Audio travels backThat network round trip can add significant latency before the model even starts working.2️⃣ Queuing → DelaysTraffic spikes→ Provider capacity gets saturated→ Requests wait in queue→ Agent pauses mid-conversation→ Caller experiences silence3️⃣ Repeated Calls → Higher CostOne conversation→ STT on every turn→ LLM on every turn→ TTS on every turn→ Repeated responses generated againA 16-turn call can create roughly 48 model calls.4️⃣ PII → Data ExposureCaller shares sensitive information→ Raw audio/transcript leaves your system→ Third-party infrastructure processes it→ Different jurisdiction + retention policies5️⃣ Observability → Blind SpotsUser says: “The call felt slow.”But where?→ STT?→ Routing?→ LLM?→ TTS?→ Network?Without step-level visibility, debugging becomes guesswork.6️⃣ Provider Lock-In → Slower InnovationBetter model becomes available→ Current app depends on one provider SDK→ Switching requires refactoring→ Evaluation gets postponed→ You stay with the existing modelThe bigger lesson:Voice AI performance is not only a model problem.It’s an execution problem.A production-ready voice architecture needs:→ Regional routing→ Smart caching→ Efficient model calls→ PII controls→ Step-level observability→ Provider flexibilityThe model generates the intelligence.The execution layer determines how efficiently users experience it.

Over the last few series, I spent a lot of time zooming out and mapping agent systems.That was useful, but one thing became pretty clear to me: the most interesting architecture is often easier to understand when you can point at a real system, inspect the code, trace the state, and ask what actually happens when something fails.That is why I’m starting a new five-part series on Hermes Agent.Not because I think Hermes is “the best” agent framework.I chose it because it is open source, inspectable, and has enough real machinery to study the things I care about: gateways, sessions, prompt assembly, memory, skills, tools, delegation, scheduling, and security. The goal is to use one running system as a case study and extract patterns that apply well beyond Hermes. Part 1 starts with a basic question:When the same agent can be reached from a terminal, chat, or another client, where does continuity actually live?The answer is not “the model.”It is in the routing, session identity, runtime, persistence, and delivery contracts around it.I trace that full path in: Hermes Agent Architecture - Part 1: Gateway, Sessions, and the Agent LoopRead it here: https://lnkd.in/gdxjv6n5What open-source agent system would you want to see torn down this way next?

Microsoft open sourced an inference framework that runs a 100B parameter LLM on a single CPU.It's called BitNet. And it does what was supposed to be impossible.No GPU. No cloud. No $10K hardware setup. Just your laptop running a 100-billion parameter model at human reading speed.Here's how it works:Every other LLM stores weights in 32-bit or 16-bit floats.BitNet uses 1.58 bits.Weights are ternary just -1, 0, or +1. That's it. No floats. No expensive matrix math. Pure integer operations your CPU was already built for.The result:- 100B model runs on a single CPU at 5-7 tokens/second- 2.37x to 6.17x faster than llama.cpp on x86- 82% lower energy consumption on x86 CPUs- 1.37x to 5.07x speedup on ARM (your MacBook)- Memory drops by 16-32x vs full-precision modelsThe wildest part:Accuracy barely moves.BitNet b1.58 2B4T their flagship model was trained on 4 trillion tokens and benchmarks competitively against full-precision models of the same size. The quantization isn't destroying quality. It's just removing the bloat.What this actually means:- Run AI completely offline. Your data never leaves your machine- Deploy LLMs on phones, IoT devices, edge hardware- No more cloud API bills for inference- AI in regions with no reliable internetThe model supports ARM and x86. Works on your MacBook, your Linux box, your Windows machine.27.4K GitHub stars. 2.2K forks. Built by Microsoft Research.100% Open Source. MIT License.

Agent Plugins: A Step Towards "Write Once, Run Anywhere" for AI AgentsOne of the biggest challenges in the AI ecosystem today is fragmentation. Every AI assistant has its own way of packaging and extending capabilities—whether it's Claude, ChatGPT, Cursor, GitHub Copilot, or Gemini. Developers often end up maintaining multiple versions of the same plugin.That's exactly the problem Agent Plugins aims to solve.Instead of creating platform-specific plugins, Agent Plugins introduces an open, vendor-neutral specification for packaging reusable AI capabilities that can work across multiple compatible AI clients.Key FeaturesCross-platform portability – Build a plugin once and use it across different AI assistants that support the specification.Reusable Skills – Package prompt-driven capabilities like code review, documentation generation, SQL optimization, report writing, and more.Native MCP Integration – Bundle Model Context Protocol (MCP) servers so your agents can seamlessly interact with GitHub, Jira, databases, cloud services, APIs, and other external tools.Standardized Plugin Manifest – A common `plugin.json` format simplifies installation, versioning, and validation.Client-specific Extensions– Add platform-specific functionality when needed without sacrificing portability.

We just shipped Orato ASR and TTS: Hindi/Hinglish speech models built for real-time voice agents.Over the past few months, we've been building speech models for Orato, along with Anand Dubey: real-time voice agents for Indian calling workflows like customer support, appointment booking, insurance, and sales.𝗪𝗵𝗮𝘁 𝘄𝗲 𝗯𝘂𝗶𝗹𝘁: • Orato ASR: a full-parameter fine-tune of Qwen3-ASR-0.6B on ~1,000 hours of Hindi/English/Hinglish calling-domain audio• Orato TTS: a Hindi/Hinglish text-to-speech model built on IndicF5-TTS, with multi-speaker and voice-clone supportFine-tuning improved WER across every benchmark we tested against the base model, with the biggest gains exactly where it matters most for a voice agent: noisy, accented, telephony-style speech (Lahaja: 25% relative improvement, Kathbath: 24.6%), not just clean studio audio nobody actually calls on.Both models are live on Hugging Face, access is auto-approved, so go ahead and try them:🔗 ASR: https://lnkd.in/g-3VDDiV🔗 TTS: https://lnkd.in/gYsk9nJQThis is just the start. Everything we learned getting here is already shaping what we're building next.Would genuinely love to hear your feedback if you give these a try.

GenAI Interviewer Question SeriesInterview: Two retrieved documents contain different answers to the same question. One is from last year, while the other was updated yesterday.Question:How would you design the retrieval and ranking pipeline to identify the authoritative and most recent information?Explanation: Metadata Filtering: Store document version, effective date, source, department, and authority level as metadata during ingestion.Retrieval: Use hybrid search to retrieve semantically relevant documents, then apply metadata filters where appropriate.Authority Ranking: Assign higher ranking to trusted sources, such as official policies, over drafts or user-generated documents.Recency Ranking: Boost documents with newer effective dates, not simply upload timestamps.Reranking: Use a cross-encoder/reranker combining relevance, authority, version, and freshness signals.Conflict Detection: If two high-confidence sources still conflict, trigger a conflict-resolution step rather than blindly selecting one.Generation: Instruct the LLM to prioritize the authoritative, latest effective document and provide citations.Evaluation: Measure retrieval accuracy, freshness, source correctness, and conflict-resolution accuracy.

Production AI is not "pick a model, write a prompt, ship."Here’s what’s actually inside an AI engineer’s brain before production.The model is only one part of the system.The hard part is making the whole thing reliable, affordable, and useful for a real user problem.Here’s the mental checklist:→ User problem:What exact job is the user trying to get done?If this is fuzzy, everything after this is optimization around the wrong target.→ Retrieval:Do we need RAG at all?If yes, what should be retrieved, how fresh should it be, and what happens when retrieval returns weak context?→ Agent behavior:Should this be a simple prompt flow or a real agent?More tool use means more power... and more ways to fail.→ Latency:How long can the user reasonably wait?A great answer in 18 seconds is often worse than a good answer in 3.→ Token cost:What does each request cost at scale?Long context, multiple retries, and agent loops quietly turn into a budget problem.→ Evals:How will we know the system is good?Not just "it worked in the demo" but task success, answer quality, safety, and consistency.→ Retries:What fails transiently, and what fails permanently?You need different handling for timeout, empty retrieval, malformed output, and tool failure.→ Rate limits:What happens under real traffic?One happy path test says nothing about production concurrency.→ Logging:Can we trace what happened for one bad response?Prompt, retrieved chunks, tool calls, model output, latency, and final decision should all be visible.→ Structured output:What happens when the model breaks your JSON?Because eventually it will.→ Guardrails:What is the model allowed to say, do, or trigger?Especially when answers can affect money, data, or customer trust.The key takeaway:Production AI is not prompt engineering.It is systems engineering around a probabilistic model.And the best teams keep coming back to one question:Does this actually solve the user’s problem... better, faster, or cheaper?

Y Combinator just open-sourced a multiplayer Agent Harness for your entire company 🤯One agent shared by everyone. Each person uses it privately, teams use it together in Slack.It's called QM. 100% Open Source under MIT license. Most agent setups are built like personal assistants. One person, one context. Run that for a whole team and everything collides. Shared credentials, tangled memory, zero permissions.QM flips the design. Every employee gets an isolated workspace with their own memory, files, keychain, and a durable sandbox where installed tools stay installed. The same agent then shows up in shared Slack channels and projects to work with the team.And it's harness-agnostic. Claude Code, Codex, OpenCode, and Pi all drive the same core, so your deployment isn't locked to one vendor.What teams run on it:• Inbox triage on a schedule, with reply drafts in your writing voice• Internal web apps the agent builds and publishes to specific people• Repo work: tests, PRs, CI monitoring• Crons and watches that keep working while nobody's onlineSecurity comes in three postures. Strict pauses every tool call for human approval. Auto screens external data with a classifier before it reaches the model. Everything is audited under each person's own credentials.Deploys to your own AWS or Fly account with one command.My favorite detail: they only accept contributions as written descriptions, not code. You describe the change in a markdown file, the maintainers implement it. One of the four listed contributors is Claude itself.

Lately, I've been interviewing AI Engineer candidates with 1–2 years of experience.One thing surprised me.Almost everyone can talk about RAG.Almost everyone has built AI agents.Most have used LangChain, LangGraph, OpenAI, Claude, or Gemini.But when the conversation moves beyond frameworks......that's where many interviews start to slow down.I ask simple questions like:"Why do embeddings work?""Why does chunk size affect retrieval?""Why does an attention mechanism matter?""What actually happens before an LLM generates the first token?"The room usually goes quiet.It made me realize something.We're getting really good at building AI applications.But we're slowly skipping the fundamentals that make those applications reliable.AI tools can write code.They can generate APIs.They can even scaffold an entire project.But they can't replace your understanding.If retrieval quality drops...If latency suddenly doubles...If hallucinations increase...If your AI agent gets stuck in a loop...The solution isn't another framework.It's understanding what's happening underneath.Frameworks will change.Models will change.The fundamentals won't.That's why, before every interview, I'd rather revise concepts like:→ Transformers→ Attention Mechanism→ Embeddings→ Tokenization→ Vector Search→ HTTP & APIs→ System Design→ Databases→ Evaluation→ Python fundamentalsThese are the concepts that help you explain why something works, not just how to build it.If you're preparing for AI Engineer interviews, don't spend all your time learning the next framework.Spend some time strengthening the foundation that every framework is built on.If you want to clear AI interviews 99% confidently, this Interview Kit is for you.Learn in depth → Practice → Perform → Crack the jobEnroll here: https://lnkd.in/guPzFkTe

Claude Code commits leak secrets 2x more than humans.(28M hardcoded secrets shipped to GitHub in 2025)GitGuardian tracked every public commit on GitHub last year and found Claude Code-assisted commits leaked credentials at 3.2%, against a 1.5% human baseline.Karpathy described vibe coding as "fully givegiving in to the vibes, embrace exponentials, and forgetting that the code even exists." When you stop reading diffs, you stop seeing what went into them.A key you pasted into the prompt for context gets written into a config file, and the agent has no reason to treat it differently from any other string.Most people end up wiring the verification themselves. A pre-commit hook that shells out to a scanner, or a script that pipes findings back into the agent's context.Both are glue you now maintain, and both run outside the session where the code gets written.SonarQube (by Sonar) ships a CLI that removes the glue entirely, and one command wires it into Claude Code:```sonar integrate claude -p <your-project>```That registers the hooks and configures the SonarQube MCP server in the same step, which gives you three layers running against the agent's work:→ Secrets detection runs on every prompt you submit and every file the agent reads or writes.→ Static analysis checks whatever your agent just wrote, using the same rules a full CI scan would apply.→ The MCP server puts those findings in Claude's context, so it reads its own issues and fixes them.Secrets detection and the MCP server both work on the SonarQube free tier, while the deeper code analysis and verification layer with is part of Sonar Vortex requires a paid plan with the proper entitlementIn the video below, a real-format GitHub token gets intercepted at prompt submission, before the model ran.Every DIY setup works until the agent's workflow changes and the glue quietly stops firing. Verification that ships with the tool doesn't have that failure mode.Link to the GitHub repo in the first comment. _____Share this with your network if you found this insightful ♻️Follow me Akshay Pachaar for more insights and tutorials on AI and Machine Learning!

Fine-Tune 100+ LLMs without writing a single line of code! LLaMA-Factory lets you train and fine-tune open-source LLMs and VLMs without writing any code. Here's why it's a game changer for fine-tuning: • Fine-tune 100+ LLMs/VLMs with built-in templates (LLaMA, Gemma, Qwen, Mistral, DeepSeek, and more). • Zero-code CLI & Web UI for training, inference, merging, and evaluation. • Supports full-tuning, LoRA, QLoRA, freeze-tuning, PPO/DPO, OFT, reward modeling, and multi-modal fine-tuning. • Speeds up training/inference with FlashAttention-2, RoPE scaling, Liger Kernel, and vLLM backend. • Integrates experiment tracking via LlamaBoard, TensorBoard, Weights & Biases, MLflow, and SwanLab. It's 100% Open Source Link to the Github repo in the comments! If you're into ML, LLMs, RAG, and AI Agents, I share AI apps, Open Source Projects and tutorials every week. Subscribe to AI Engineering (it's free): https://lnkd.in/gfkzKZYk

Google recently launched the new AI File Search API -- which means you may not need to set up your own vector DBs for RAG. This is a fully managed RAG layer where Google handles storage, chunking, embeddings, retrieval, and citations for you. You just upload files and call generateContent. That’s it. What it does: - Makes RAG dead simple for solo builders and teams who don’t want to manage infra. - Cuts down cost + dev time since storage + query-time embeddings are free. How it works: - You upload files (PDFs, DOCX, TXT, JSON, code files, etc.) into a File Search Store. - Google automatically chunks, embeds, and indexes them using the latest Gemini Embedding model. - At query time, the model performs vector search over your uploaded data. - Relevant chunks are injected automatically into the prompt inside generateContent. - Responses come with citations that point to the exact chunks used. - You only pay once for initial embedding (around $0.15 per million tokens), everything else is free. It’s basically RAG without the whole “RAG pipeline.” Pretty exciting if you're building AI tools, internal assistants, customer support bots, or anything that needs grounding in private data. ♻️ Share it with anyone who’s trying to simplify their RAG stack :) I share tutorials on how to build + improve AI apps and agents, on my newsletter 𝑨𝑰 𝑨𝒈𝒆𝒏𝒕 𝑬𝒏𝒈𝒊𝒏𝒆𝒆𝒓𝒊𝒏𝒈: https://lnkd.in/gaJTcZBR Link to the announcement: https://lnkd.in/gXTPhX57

Agent-maintained wikis will become the default context layer for AI systems. And OpenWiki is one of the best examples I've seen... → https://lnkd.in/deSmhGBn Traditionally, documentation has been a manual process. You write it. It slowly goes out of date. Nobody wants to maintain it. Now we have OpenWiki. It continuously builds and maintains a wiki for either: • Your codebase • Your personal knowledge This is also how I think about LLM wikis. I use them as the context layer between my Second Brain and the work my AI systems actually perform. Instead of giving an agent direct access to everything I know, I let it navigate a structured wiki that evolves over time. Then the wiki becomes an interface between humans and AI agents. For repositories, it can: • Generate documentation • Keep it updated as the code changes • Create architecture diagrams • Explain relationships between components For personal knowledge, it can ingest sources like: • Local repositories • Gmail • Notion • Web search • Hacker News • X ...and synthesize them into a continuously evolving personal wiki. OpenWiki outputs everything in Google's Open Knowledge Format (OKF). This means the knowledge isn't trapped inside a proprietary database. It's stored as linked Markdown documents that are: • Human-readable • LLM-readable • Git-friendly • Vendor-neutral We'll see many more systems adopt this pattern. Not because it's another documentation tool… But because it gives agents a living knowledge layer instead of asking them to rediscover the same information every session. If you're building AI assistants, coding agents, or long-term memory systems, OpenWiki is definitely worth studying. GitHub: https://lnkd.in/deSmhGBn

This is the most (practical) Agentic AI Course. Taught by Andrew Ng, available for free on Deeplearning AI. Also with practical assignments to complete :) Here's what it covers: Reflection → AI reviews its own output. → Catches mistakes automatically. → Like code review, but smarter. Tool Use → Connects AI to real APIs. → Databases, web search, code execution. → Not just text generation anymore. Planning → Breaks big tasks into steps. → Adapts when things go wrong. → Real problem solving, not scripts. Multi-Agent Systems → Multiple AI agents working together. → Each one handles a specific job. → This is how production systems scale. Check it out here: https://lnkd.in/dtiWR7qn Bookmark this before you lose it. Repost ♻️ for people learning agentic AI. Check my profile for more resources on AI 👋

AI Engineer Interview Question: "Your agent crashes at step 200 of 240. What happens next?"Most candidates say "we retry the run" and stop there, which is the wrong half of the answer. What the interviewer is actually testing:Retrying is the easy part. The cost of that retry is the real question.200 steps is 40 minutes of tokens you already paid for, plus tool calls that already changed things. If the run state lived in process memory, a pod eviction or a routine deploy takes all of it. You start again at step 1, pay for every step twice, and every write fires a second time.A journaled run goes forward from step 201 instead. 3 things make that work.1. Checkpoint the run state. Write each finished step to a durable store before the next one starts. The unit is the step boundary. LangGraph's MemorySaver is in-process, so it dies with the process.2. Key every mutation. Mint the idempotency key before the call and store it with the step. The dedupe has to live at the provider, since your retry logic died too.3. Replay reads, skip sends. Repeatable calls run again. Anything that spends money or reaches a human loads its recorded result. Model output counts as a side effect.One line worth saying out loud in that interview: a checkpoint is not durable execution. Something outside the process still has to notice the death and restart the run.What is your agent's run state sitting in right now, Postgres or the process that is about to get redeployed?Connect/Follow for more such deep dives.

Ultimate guide for Building AI Agents. 📹 Videos: 1. LLM Introduction: https://lnkd.in/dYunDzPz 2. LLMs from Scratch: https://lnkd.in/dKpTM6QP 3. Agentic AI Overview (Stanford): https://lnkd.in/dYfBSz7a 4. Building and Evaluating Agents: https://lnkd.in/dFAvUnFW 5. Building Effective Agents: https://lnkd.in/dmEFwhEX 6. Building Agents with MCP: https://lnkd.in/d6TY_jS5 7. Building an Agent from Scratch: https://lnkd.in/dMFgGxhr 8. Philo Agents: https://lnkd.in/d8DS_d_2 🗂️ Repos 1. GenAI Agents: https://lnkd.in/dKbmSuuj 2. Microsoft's AI Agents for Beginners: https://lnkd.in/dzs92TgE 3. Prompt Engineering Guide: https://lnkd.in/gJjGbxQr 4. Hands-On Large Language Models: https://lnkd.in/dxaVF86w 5. AI Agents for Beginners: https://lnkd.in/dzs92TgE 6. GenAI Agentshttps://lnkd.in/dEt72MEy 7. Made with ML: https://lnkd.in/d2dMACMj 8. Hands-On AI Engineering:https://lnkd.in/dSWSJuax 9. Awesome Generative AI Guide: https://lnkd.in/dJ8gxp3a 10. Designing Machine Learning Systems: https://lnkd.in/dEx8sQJK 11. Machine Learning for Beginners from Microsoft: https://lnkd.in/dBj3BAEY 12. LLM Course: https://lnkd.in/dcnAPv8h 🗺️ Guides 1. Google's Agent Whitepaper: https://lnkd.in/gFvCfbSN 2. Google's Agent Companion: https://lnkd.in/gfmCrgAH 3. Building Effective Agents by Anthropic: https://lnkd.in/gRWKANS4. 4. Claude Code Best Agentic Coding practices: https://lnkd.in/gs99zyCf 5. OpenAI's Practical Guide to Building Agents: https://lnkd.in/guRfXsFK 📚Books: 1. Understanding Deep Learning: https://lnkd.in/dTTE2K9X 2. Building an LLM from Scratch: https://lnkd.in/g2YGbnWS 3. The LLM Engineering Handbook: https://lnkd.in/gWUT2EXe 4. AI Agents: The Definitive Guide - Nicole Koenigstein: https://lnkd.in/dJ9wFNMD 5. Building Applications with AI Agents - Michael Albada: https://lnkd.in/dSs8srk5 6. AI Agents with MCP - Kyle Stratis: https://lnkd.in/dR22bEiZ 7. AI Engineering: https://lnkd.in/dzS6DHyW 📜 Papers 1. ReAct: https://lnkd.in/gRBH3ZRq 2. Generative Agents: https://lnkd.in/gsDCUsWm. 3. Toolformer: https://lnkd.in/gyzrege6 4. Chain-of-Thought Prompting: https://lnkd.in/gaK5CXzD. 5. Tree of Thoughts: https://lnkd.in/gRJdv_iU. 6. Reflexion: https://lnkd.in/gGFMgjUj 7. Retrieval-Augmented Generation Survey: https://lnkd.in/gGUqkkyR. 🧑🏫 Courses: 1. HuggingFace's Agent Course: https://lnkd.in/gmTftTXV 2. MCP with Anthropic: https://lnkd.in/geffcwdq 3. Building Vector Databases with Pinecone: https://lnkd.in/gCS4sd7Y 4. Vector Databases from Embeddings to Apps: https://lnkd.in/gm9HR6_2 5. Agent Memory: https://lnkd.in/gNFpC542 6. Building and Evaluating RAG apps: https://lnkd.in/g2qC9-mh

A two-person red team used AI agents to pentest applications the way a human researcher would, not a scanner and it started closing gaps enterprise security teams were missing.Now the tool behind it is open-source.It is called Strix.Most people run a vulnerability scan by giving AI one static task:"Flag anything that looks like a known CVE pattern."Strix takes a more active approach.First, the agent maps the application's live attack surface.Then it launches itself against each entry point, attempting to actually break it.Each run happens in an isolated environment, where it can:> Test endpoints dynamically instead of pattern-matching> Build a working proof-of-concept exploit> Inspect raw requests through a built-in HTTP proxy> Confirm the bug is real before reporting itIt behaves like a real security researcher instead of a static scanner — dynamically testing applications and validating vulnerabilities with proof-of-concept exploits.It doesn't tell you "this might be exploitable." It shows you the exploit.This is an open-source AI agent that replaces the first pass of a pentest.github.com/usestrix/strix

LMCache: reuse KV cache to speed up AI inferenceLong-context and multi-turn LLM apps often recompute the same tokens again and again. LMCache reduces that wasted work.Why this matters:- Lower time-to-first-token for long prompts and RAG- Better GPU utilization under repeated or similar requestsHow LMCache works:- Reuses KV cache for repeated text, not just prefixes- Stores KV cache on GPU, CPU, or disk- Allows cache reuse across different serving instances- Integrates with vLLM and SGLang for KV cache offloading- Works well for multi-turn chat and RAG workloads- It’s a practical way to treat KV cache as shared infrastructure instead of a per-request artifact.♻️ Share it with anyone who’s running LLMs in production :)I share tutorials on how to build + improve AI apps and agents, on my newsletter 𝑨𝑰 𝑨𝒈𝒆𝒏𝒕 𝑬𝒏𝒈𝒊𝒏𝒆𝒆𝒓𝒊𝒏𝒈: https://lnkd.in/gaJTcZBRLink to repo: https://lnkd.in/ekp-uBjy