Audio8 ASR Infinite: Building Streaming Speech Recognition That Can Listen ForeverSpeech recognition is easy—until you ask it to listen forever.Today we’re open-sourcing Audio8 ASR Infinite, a streaming ASR model designed for ultra-low latency, unlimited-length audio, and 24/7 transcription without drift.It also includes built-in semantic turn detection, allowing the model to distinguish between a thinking pause, a stutter, and the actual end of a turn—closer to how a human listener understands conversation.1. Open sourceThe preview release includes:The Audio8 ASR Infinite streaming modelAn adapted vLLM runtimeDocker deploymentLocal inference examplesThe model is built for:24/7 transcriptionFull-duplex, real-time voice interactionAlways-on audio applicationsIt is low-latency, bilingual in Chinese and English, and designed to keep listening continuously.2. How does it listen 24/7 without drifting?In simple terms:One shared audio-text clockAudio and text move on the same clock. Every 80 ms, the model emits exactly one token, resulting in 12.5 decisions per second.Latency is configurableThe transcription delay can be set between 240 and 560 ms. You can trade latency for accuracy without changing the model weights.A rolling context windowA 30-second rolling window keeps memory bounded. Older context is removed, and position indices rotate back to zero. After 10 hours of operation, the model behaves like it did during the first minute.Semantic turn detectionTurn-taking is handled semantically rather than through acoustic volume alone. The model can recognize whether someone is still thinking, stuttering, or has actually finished speaking.3. Benchmark resultsWe evaluated Audio8 ASR Infinite against two streaming baselines at the same operating point: 480 ms delay and 80 ms clock. Lower is better.On Chinese speech, the gap is substantial:AISHELL-1 CER: 1.75 vs. 16.80 for Voxtral-Mini-4B-RealtimeAISHELL-4 CER: 2.89 vs. 16.46On English speech, the results are closer:LibriSpeech test-clean WER: 3.04 for Audio8 ASR Infinite vs. 2.21 for VoxtralWe prioritized Chinese during post-training, so English clean-speech performance remains an area for improvement.Across the four reported test sets, the average score was:Audio8 ASR Infinite: 3.62Voxtral-Mini-4B-Realtime: 10.25Nemotron-3.5-ASR: 9.52Nemotron-3.5 was measured at 560 ms delay, which gives it a longer latency budget and therefore a more favorable operating point.

Claude Code quietly ignored your project instructions — and told you nothing about it.Here's what happened. On September 18, Claude Code added support for AGENTS.md, the cross-tool instruction file already read by 30+ coding agents. Big announcement. Real gap closed.Except it didn't actually work for a meaningful chunk of users.An independent engineer ran a simple test: drop a unique canary word into an AGENTS.md file, ask Claude Code to recite it back. Then vary the environment.What they found:• Telemetry disabled? File silently skipped.• Running on Amazon Bedrock, Google Vertex AI, or Microsoft Foundry? Silently skipped.• Behind a corporate gateway that blocks "nonessential" traffic? Silently skipped.• No warning, no error, no log line — the session just ran without your instructions.The root cause: reading a local markdown file had been wired to a remote feature flag. If the client couldn't reach Anthropic's servers to check whether the feature was "on," it defaulted to off. A capability that should need zero network access ended up depending on one.The people most affected weren't random — they were exactly the users most likely to have adopted AGENTS.md in the first place: teams standardizing one instruction file across multiple AI coding tools, privacy-conscious developers who turn telemetry off on purpose, and enterprises on managed cloud platforms.The workaround was almost insulting in its simplicity: a one-line CLAUDE.md file containing @AGENTS.md, which uses Claude Code's existing import mechanism and never depended on the flag at all.Five days after launch — the same day the investigation was published — Anthropic shipped v2.1.281, removing the gate for telemetry-disabled sessions, Bedrock, Vertex, Foundry, and LLM gateways.What I find most instructive here isn't the bug — it's the pattern. The same two environment variables were already known to gate an unrelated feature (the post-session feedback survey), and that gating was documented and intentional. This one wasn't. The difference between "designed behavior" and "silent side effect" often comes down to whether anyone thought to test the edge case before shipping.Worth remembering next time you're staging a feature behind a flag: closed-by-default fallbacks are fine for gradual rollouts to the general population. They're much riskier for capabilities that a fixed, non-shrinking subset of your users structurally cannot reach.If you're running Claude Code, this is a good moment to check claude --version and confirm you're on v2.1.281 or later.Full piece on mer.vin — link posted separately in comments.

Claude Code never used a vector DB. Cursor just deleted theirs.We turned ours off too a couple of months ago. It wasn't broken. The model just got better at searching than our retrieval was. Toffu's memory used to be the standard setup. Everything a customer told us, and every file they uploaded, got broken into small "memories," embedded and stored in Pinecone. Before each message we ran a similarity search and put the top 3 matches into the prompt, whether the agent asked for them or not. It worked well for a long time. Back then models weren't good at deciding what to look up, so we did it for them. That's no longer true. Today's models are good at searching when you give them the right tools, so we let the agent decide:- What it must always know (brand, goals, rules) lives in the customer's instructions, which the agent always has.- Working notes are saved by name and found by keyword, not by similarity score.- Past conversations and uploaded files are searched with plain keyword queries.- Live numbers come straight from the ad accounts, never from a stored snapshot. No embeddings, no index to keep in sync, no memories pulled in on a hunch. Every lookup shows up in the trace, so you can see exactly what the agent searched for and why.  We weren't first. Claude Code shipped with no vector index at all, only grep and file reads, and the Anthropic team said agentic search beat RAG in their testing. Cursor just followed. From their forum: "models have gotten really good at using grep / indexed search, so the older dedicated semantic search path was rapidly no longer helping in a meaningful way." They no longer compute or store embeddings of your code. Vector DBs weren't a mistake. They made up for something models couldn't do yet. When the model gets better, check what infrastructure you built around its old weaknesses. Some of it is now in the way.

BREAKING: Zuckerberg just described the near-future of computing, and it has nothing to do with screens.His call: within 5 years, every person on Earth has a personal AI that knows their life, understands their goals, and does the work for them.Not a chatbot. Not a search box.An agent that is deeply, intimately embedded in how you live.When the person building the social layer for 3 billion people says this is where we're going, it's not a prediction.It's a roadmap.Is the personal AI agent the most valuable product anyone can build right now?

Looking for advice: getting a Malayalam TTS model to run in real time on CPU.I fine-tuned F5-TTS on ~15 h of my own Youtube data (free Kaggle GPUs only) and benchmarked it on a 2-core CPU:📉 64 steps → RTF 135 (CER 0.17)⚡ 16 steps + EPSS → RTF 33.5, 4× faster (CER 0.22, same as 32 steps)🎯 EPSS vs uniform steps at 7 steps: CER 0.26 vs 0.38🔢 + INT8 → 1.27× more, no quality loss🧩 ONNX Runtime → no gain; its INT8 version broke the outputNet: ~5× faster, still ~26× short of real time. Inference tricks have hit their limit; the rest must come from the model.The goal: voice assistants for Malayalam, and other languages with little speech data, that run without GPUs, so communities with limited hardware can still build on speech AI. Speech recognition is next.If you've distilled a flow-matching TTS model to a few steps, removed classifier-free guidance, or built a CPU-friendly single-speaker student model, I'd really value your pointers. Notebook available on request.

Not even 2 weeks after launch, open models already caught up with Jev.We ran benchmarks for several eval tasks, prompt injection detection, PII, moderation, but also routing, tool call choosing etc, 11 in total, Jev vs 15 open models up to 28B. We controlled the most we could for out of distribution so they can't "cheat".Open models tie Jev on 8 of the 11 tasks, beat it on PII (Eikos-27B 95.2% vs 90.8%) and tool routing (Shisa DE-1 81.3% vs 78.3%), and lose on off-topic detection (Kev-9B 89.6% vs Jev 93.4%). On the average, Eikos-27B gets 78.5% and Jev 78.4%, but that's a 27B model, you need a proper GPU like an H100 to run it.We run LangWatch Instant Evals on Jev so we really care about which one is best. I think small judge models are here to stay, and evals is our thing, so we'll keep benchmarking every new one that comes out and run your evals on whatever is winning. For now it's still Jev, it's the only one that scored on all 11 tasks, and it's tied or ahead on 9 of them.Per-task charts and the full method are in the first comment.

This shouldn't be free.Someone open sourced a fully local AI meeting notetaker that kills Otter, Fireflies, and Fathom in one Rust app.It's called Meetily. Every meeting gets recorded, transcribed, and summarized entirely on your own machine. Zero cloud. Zero API calls to a company you don't trust with your audio.The pitch isn't just privacy. It's speed too.→ Whisper and Parakeet models both bundled in, 4x faster live transcription→ Ollama handles summaries locally, or plug in Claude, Groq, OpenRouter, or any OpenAI-compatible endpoint→ Captures your mic and system audio at the same time with intelligent ducking so nothing clips→ GPU acceleration ships automatic. Metal and CoreML on Apple Silicon. CUDA on NVIDIA. Vulkan on AMD and Intel.→ Import any old recording and re-transcribe it with a better model or a different language→ Native app for macOS and Windows. Linux builds from source.The average data breach costs $4.4M. Every cloud notetaker on the market is a compliance risk waiting to fire.Meetily is what happens when engineers finally build the alternative.13.2K stars. MIT License. 100% Opensource.https://lnkd.in/geyf7rsR

One of my AI Engineer interview questions with Philips started with this broken RAG system👇 And here is how you answer it. Your RAG system gives hallucinated answers. Where would you debug first? There are actually quite a few places where things could have gone wrong before the information reached the LLM. So I would start by tracing what happened to between the user query and what information eventually made it into the context. → Did the system call the right tools? → Any metadata filtering issues? → Anything wrong with query rewriting, for example adding the wrong time constraints? → Did retrieval actually fetch the right chunks? → Is the chunk quality good? What is your chunking strategy, and how are you evaluating chunk quality (e. using chunk attribution)? → Do you retrieve all relevant chunks? Look at 𝐫𝐞𝐜𝐚𝐥𝐥: 𝘰𝘶𝘵 𝘰𝘧 𝘢𝘭𝘭 𝘤𝘩𝘶𝘯𝘬𝘴 𝘳𝘦𝘭𝘦𝘷𝘢𝘯𝘵 𝘵𝘰 𝘵𝘩𝘦 𝘲𝘶𝘦𝘳𝘺, 𝘸𝘩𝘢𝘵 𝘱𝘦𝘳𝘤𝘦𝘯𝘵𝘢𝘨𝘦 𝘪𝘴 𝘳𝘦𝘵𝘳𝘪𝘦𝘷𝘦𝘥? → Did we retrieve too much irrelevant context? Look at context 𝐩𝐫𝐞𝐜𝐢𝐬𝐢𝐨𝐧: 𝘰𝘶𝘵 𝘰𝘧 𝘢𝘭𝘭 𝘵𝘩𝘦 𝘥𝘰𝘤𝘶𝘮𝘦𝘯𝘵𝘴 𝘳𝘦𝘵𝘳𝘪𝘦𝘷𝘦𝘥, 𝘸𝘩𝘢𝘵 𝘱𝘦𝘳𝘤𝘦𝘯𝘵𝘢𝘨𝘦 𝘪𝘴 𝘳𝘦𝘭𝘦𝘷𝘢𝘯𝘵 𝘵𝘰 𝘵𝘩𝘦 𝘲𝘶𝘦𝘳𝘺? Now suppose all of that is working. We get the right chunks, but the answer is still wrong. Then the debugging path changes. → Was there conflicting information, for example information from different timelines with completely different views? → Were the prompt instructions clear? → How are we constructing the context? Does the metadata stay together with the chunk? If you just dump chunks together, you may not give the LLM enough context to understand what that text represents. Things like source, timestamp, or other metadata can give the LLM a better world view of the retrieved information. The solution depends on the failure mode. If user queries are ambiguous or underspecified: → Maybe query rewriting. If metadata filtering is wrong: → Check the filtering logic. If retrieval misses exact terms used in the user query: → Hybrid search may help. Although it is often already the default. If retrieved results are relevant but noisy: → Reranking One interesting suggestion I got from the interviewer was about where you place the most relevant chunks after reranking. For example, if you retrieve 5 chunks, instead of simply ordering them from most to least relevant, what if you put the most important ones at top #1 and bottom #5? The reasoning was the “lost in the middle” problem. And this is exactly why observability is non-negotiable. At this point, we have implemented so many things: guardrails, query rewriting, metadata filtering, retrieval, LLM calls, tool calls, tool arguments etc. We need end-to-end traces and span-level visibility. If you only see the final answer, you don’t know where things went wrong. What other RAG failure modes have you run into. Any debugging tip you would share? 💾 Save this for your next interview. ♻️ Repost if you found this useful 💚

One of my AI Engineer interview questions with Philips started with this broken RAG system👇 And here is how you answer it.Your RAG system gives hallucinated answers. Where would you debug first?There are actually quite a few places where things could have gone wrong before the information reached the LLM.So I would start by tracing what happened to between the user query and what information eventually made it into the context.→ Did the system call the right tools?→ Any metadata filtering issues?→ Anything wrong with query rewriting, for example adding the wrong time constraints?→ Did retrieval actually fetch the right chunks?→ Is the chunk quality good? What is your chunking strategy, and how are you evaluating chunk quality (e. using chunk attribution)?→ Do you retrieve all relevant chunks? Look at 𝐫𝐞𝐜𝐚𝐥𝐥: 𝘰𝘶𝘵 𝘰𝘧 𝘢𝘭𝘭 𝘤𝘩𝘶𝘯𝘬𝘴 𝘳𝘦𝘭𝘦𝘷𝘢𝘯𝘵 𝘵𝘰 𝘵𝘩𝘦 𝘲𝘶𝘦𝘳𝘺, 𝘸𝘩𝘢𝘵 𝘱𝘦𝘳𝘤𝘦𝘯𝘵𝘢𝘨𝘦 𝘪𝘴 𝘳𝘦𝘵𝘳𝘪𝘦𝘷𝘦𝘥?→ Did we retrieve too much irrelevant context? Look at context 𝐩𝐫𝐞𝐜𝐢𝐬𝐢𝐨𝐧: 𝘰𝘶𝘵 𝘰𝘧 𝘢𝘭𝘭 𝘵𝘩𝘦 𝘥𝘰𝘤𝘶𝘮𝘦𝘯𝘵𝘴 𝘳𝘦𝘵𝘳𝘪𝘦𝘷𝘦𝘥, 𝘸𝘩𝘢𝘵 𝘱𝘦𝘳𝘤𝘦𝘯𝘵𝘢𝘨𝘦 𝘪𝘴 𝘳𝘦𝘭𝘦𝘷𝘢𝘯𝘵 𝘵𝘰 𝘵𝘩𝘦 𝘲𝘶𝘦𝘳𝘺?Now suppose all of that is working. We get the right chunks, but the answer is still wrong.Then the debugging path changes. → Was there conflicting information, for example information from different timelines with completely different views?→ Were the prompt instructions clear?→ How are we constructing the context? Does the metadata stay together with the chunk?If you just dump chunks together, you may not give the LLM enough context to understand what that text represents. Things like source, timestamp, or other metadata can give the LLM a better world view of the retrieved information.The solution depends on the failure mode.If user queries are ambiguous or underspecified:→ Maybe query rewriting. If metadata filtering is wrong:→ Check the filtering logic.If retrieval misses exact terms used in the user query:→ Hybrid search may help. Although it is often already the default.If retrieved results are relevant but noisy:→ RerankingOne interesting suggestion I got from the interviewer was about where you place the most relevant chunks after reranking.For example, if you retrieve 5 chunks, instead of simply ordering them from most to least relevant, what if you put the most important ones at top #1 and bottom #5? The reasoning was the “lost in the middle” problem.And this is exactly why observability is non-negotiable.At this point, we have implemented so many things: guardrails, query rewriting, metadata filtering, retrieval, LLM calls, tool calls, tool arguments etc.We need end-to-end traces and span-level visibility. If you only see the final answer, you don’t know where things went wrong.What other RAG failure modes have you run into. Any debugging tip you would share?

Stanford + NVIDIA just answered TypeSafe's Jev with CLM-8B. And it's open source.Here's the simple idea:Normal LLMs write answers word by word. That's slow.CLM looks at the situation, looks at the possible actions, and picks the best match. No writing. Just choosing.What the numbers say:✅ Up to 9x faster than Jev✅ 16.5 ms per decision vs 149.8 ms for Jev (T-Rex game test)✅ 13x faster when choosing from ~1,000 options✅ New best scores on coding agent benchmarks: DeepSWE 81.6%, Terminal-Bench 2.1 87.6%✅ Free to use — Apache 2.0 weightsBut let's be fair 👇Jev was still more accurate in some tests. On tool-calling (BFCL v4), Jev hit 99.2% vs CLM's 95.2%. So CLM wins on speed, not always on accuracy.Why I find this exciting:Only ~20M parameters per head are trained on top of a frozen Qwen3-8B. That means fine-tuning is cheap, and you can run it on your own servers.For anyone building AI agents, this matters. Agents make hundreds of small choices. If each choice is 10x faster, the whole agent feels instant.A bigger multimodal CLM-35B is coming in early October. I'll be watching.Check - https://lnkd.in/ghgbecXS

We use LLMs to write answers, then call another LLM to judge them. But when the judgment is a handful of bounded decisions, do we need another round of text generation? Jev offers a fast and cheaper path: give it the state, ask predefined questions, and receive typed values directly. That makes agent evaluation one of its most interesting use cases. We are in to just week one of Jev release... as more results and Benchmarks become available, it will become clearer how much workload it can potentially pick up from your eval harness. Read more in the article I wrote below

I used to think building a 𝗩𝗼𝗶𝗰𝗲 𝗔𝗜 𝗔𝗴𝗲𝗻𝘁 was mostly about choosing a good LLM. I was wrong. 😄 The architecture looks pretty simple: 🎙️ 𝗦𝗧𝗧 → 🧠 𝗟𝗟𝗠 → 🔊 𝗧𝗧𝗦 But making all three work together 𝗶𝗻 𝗮 𝗿𝗲𝗮𝗹 𝗰𝗼𝗻𝘃𝗲𝗿𝘀𝗮𝘁𝗶𝗼𝗻 is a completely different problem. We’ve been building and testing our Voice AI agent with real conversations, and one thing surprised me: 🔊 𝗧𝗧𝗦 𝗶𝘀 𝗮𝗰𝘁𝘂𝗮𝗹𝗹𝘆 𝘁𝗵𝗲 𝗯𝗶𝗴𝗴𝗲𝘀𝘁 𝗰𝗵𝗮𝗹𝗹𝗲𝗻𝗴𝗲. Not just technically - 𝗳𝗶𝗻𝗮𝗻𝗰𝗶𝗮𝗹𝗹𝘆 𝘁𝗼𝗼. Our current cost breakdown is roughly: 🔊 𝗧𝗧𝗦 — 𝟳𝟮% 🧠 𝗟𝗟𝗠 — 𝟮𝟬% 🎙️ 𝗦𝗧𝗧 — 𝟳% So the obvious thought is: “Let's use a cheaper LLM.” But that's not always the answer. We tested cheaper models and found something interesting: 𝗜𝗳 𝘁𝗵𝗲 𝗔𝗜 𝘁𝗮𝗹𝗸𝘀 𝗺𝗼𝗿𝗲, 𝗧𝗧𝗦 𝗰𝗼𝘀𝘁𝘀 𝗴𝗼 𝘂𝗽. So sometimes a cheaper LLM can actually make the 𝗼𝘃𝗲𝗿𝗮𝗹𝗹 𝘃𝗼𝗶𝗰𝗲 𝗮𝗴𝗲𝗻𝘁 𝗺𝗼𝗿𝗲 𝗲𝘅𝗽𝗲𝗻𝘀𝗶𝘃𝗲. That's when you realise: 𝗕𝘂𝗶𝗹𝗱𝗶𝗻𝗴 𝗩𝗼𝗶𝗰𝗲 𝗔𝗜 𝗶𝘀𝗻'𝘁 𝗷𝘂𝘀𝘁 𝗮𝗯𝗼𝘂𝘁 𝗺𝗮𝗸𝗶𝗻𝗴 𝗔𝗜 𝘀𝗺𝗮𝗿𝘁𝗲𝗿. It's about making the entire conversation 𝗳𝗮𝘀𝘁𝗲𝗿, 𝘀𝗵𝗼𝗿𝘁𝗲𝗿, 𝗰𝗵𝗲𝗮𝗽𝗲𝗿 𝗮𝗻𝗱 𝗺𝗼𝗿𝗲 𝗵𝘂𝗺𝗮𝗻. We are now experimenting with: ⚡ 𝗟𝗼𝘄𝗲𝗿 𝗹𝗮𝘁𝗲𝗻𝗰𝘆 🗣️ 𝗦𝗵𝗼𝗿𝘁𝗲𝗿, 𝗻𝗮𝘁𝘂𝗿𝗮𝗹 𝗿𝗲𝘀𝗽𝗼𝗻𝘀𝗲𝘀 🔊 𝗕𝗲𝘁𝘁𝗲𝗿 𝗧𝗧𝗦 𝘃𝗼𝗶𝗰𝗲𝘀 💾 𝗔𝘂𝗱𝗶𝗼 𝗰𝗮𝗰𝗵𝗶𝗻𝗴 🌍 𝗛𝗶𝗻𝗱𝗶 + 𝗚𝘂𝗷𝗮𝗿𝗮𝘁𝗶 + 𝗘𝗻𝗴𝗹𝗶𝘀𝗵 🎯 𝗕𝗲𝘁𝘁𝗲𝗿 𝗶𝗻𝘁𝗲𝗿𝗿𝘂𝗽𝘁𝗶𝗼𝗻 𝗵𝗮𝗻𝗱𝗹𝗶𝗻𝗴 💰 𝗖𝗼𝘀𝘁 𝗼𝗽𝘁𝗶𝗺𝗶𝘀𝗮𝘁𝗶𝗼𝗻 And honestly, the hardest part is still the same: 𝗠𝗮𝗸𝗶𝗻𝗴 𝗔𝗜 𝘀𝗼𝘂𝗻𝗱 𝗹𝗶𝗸𝗲 𝘀𝗼𝗺𝗲𝗼𝗻𝗲 𝘆𝗼𝘂 𝗮𝗰𝘁𝘂𝗮𝗹𝗹𝘆 𝘄𝗮𝗻𝘁 𝘁𝗼 𝘁𝗮𝗹𝗸 𝘁𝗼. Especially for India 🇮🇳 Where conversations can move between 𝗛𝗶𝗻𝗱𝗶, 𝗚𝘂𝗷𝗮𝗿𝗮𝘁𝗶, 𝗘𝗻𝗴𝗹𝗶𝘀𝗵, 𝗛𝗶𝗻𝗴𝗹𝗶𝘀𝗵, numbers, names and local pronunciation - sometimes in the same call. There is still a 𝗟𝗢𝗧 𝘁𝗼 𝘀𝗼𝗹𝘃𝗲. But that's also what makes it exciting. 🚀 We're building. Measuring real calls. Breaking things. Fixing them. And repeating. 🔁 𝗧𝗵𝗶𝘀 𝗶𝘀 𝘁𝗵𝗲 𝗸𝗶𝗻𝗱 𝗼𝗳 𝗽𝗿𝗼𝗯𝗹𝗲𝗺 𝘄𝗲 𝗹𝗼𝘃𝗲 𝘀𝗼𝗹𝘃𝗶𝗻𝗴 𝗮𝘁 Blutec.AI From India 🇮🇳 Building AI that people can actually 𝘁𝗮𝗹𝗸 𝘁𝗼. #VoiceAI #AI #LLM #TTS #STT #AIEngineering #FoundingEngineer #BuildInPublic #BluTecAI #AIIndia

Turn any open LLM into a Jev-style model:Researchers just open-sourced AnyJev, a Python library that extracts typed choices, yes/no judgments, scores, and probabilities from causal LLMs.Beyond its raw baseline, AnyJev offers three levels depending on how much labeled data and calibration you need:- L0 requires no labels. It rotates the answer options to reduce position bias, but its probabilities remain uncalibrated.- L1 uses 100-500 labeled examples per question to calibrate those probabilities through temperature scaling. It improves confidence estimates without changing the answer ranking.- L2 uses 100-300 labels to fit a closed-form head on an intermediate hidden state. It leaves model weights untouched and can stop inference before the full forward pass completes.The main constraint is model access. AnyJev requires access to logits or hidden states, so it is built for open models. L2 heads are also specific to a model and question. It is compatible with several open causal LLMs.Find the repo in the replies

I spent 8+ hours collecting resources so you can become an AI agent engineer without drowning in random tutorials.If you are starting from zero, follow this order. Phase 1: Understand the fundamentals1. Learn AI Harness Engineering in 14 Minutes https://lnkd.in/gQASEFDm2. Real AI Agent Stack: Harness → Loop → Graphhttps://lnkd.in/gYdS-57T3. AI Agent Graph Engineering in 21 Minuteshttps://lnkd.in/gd-sbyQX4. Loop Engineering + Graph Engineeringhttps://lnkd.in/geUiEJADPhase 2: actually build an agent harness5. Claude Agent SDK Full Workshop, Anthropichttps://lnkd.in/gaP7JenF6. Anthropic Workshop: Build Agents That Run for Hourshttps://lnkd.in/gu4q-ZZt7. Harness Engineering: Building the Production Cage, AWShttps://lnkd.in/gYj2m4WSPhase 3: Learn context, memory, and orchestration8. When to Build Your Own Agent Harness, Harrison Chasehttps://lnkd.in/g_AYWWJj9. Context Engineering Our Way to Long-Horizon Agentshttps://lnkd.in/gzbjgGxD10. Building an AI Agent From Scratch in Pythonhttps://lnkd.in/gzAg64wR11. What if the Harness Mattered More Than the Model?https://lnkd.in/gFPDNgcxPhase 4: production thinking12. One Million Lines of Code. Zero Keystrokes.https://lnkd.in/gXgYMQFm13. Inside the Stack Behind Antigravity, Claude Code & Cursorhttps://lnkd.in/gDj23Yzf14. How AWS Thinks About Agent Harnesseshttps://lnkd.in/gTT4wfUb15. SE Radio: Harness Engineering for AI Agentshttps://lnkd.in/gwH8QYx3If you only have time for two long sessions:→ Watch #5 to learn how to build→ Watch #8 to understand when the harness itself becomes the product

Curating clinical variables from free-text notes is tedious. General LLMs can help, but processing thousands of notes can be slow and costly. Inspired by Jev and the open-source community, we’re releasing MedJev to turn clinical notes into structured fields on consumer GPUs.A 0.8B model + 43 MB LoRA adapter, trained to extract 11 predefined clinical variables.On our benchmark of 2,895 held-out notes: ⚡ 62 ms per note, 4.6× faster than the Jev API 🎯 87.8% accuracy vs. 60.2% for Jev 🏠 Runs locally, patient text stays on your networkData & Code: github.com/JunMa11/MedJevModel: https://lnkd.in/dyebBewd

Spotify open-sourced a Claude Code setup that can cut bulk-read token usage by ~90%.And the interesting part isn't the model.It's the architecture.Most coding agents waste expensive tokens on I/O-heavy work:→ Reading 5 large files to answer 1 question→ Scanning dozens of existing tests before generating 1 similar test→ Copying boilerplate patterns into the context→ Repeating information the main model doesn't actually need to reason aboutSpotify's solution:Don't make the expensive model do everything.They built a Claude Code plugin called shunt that routes predictable, I/O-heavy tasks to cheaper worker models.1️⃣ Bulk-readerA cheaper model reads the large files and returns a structured summary.Claude gets the answer, not thousands of lines of source code.2️⃣ Code-writerGive the worker:→ A specification→ A reference file→ The expected outputIt generates the boilerplate and can write it directly to disk.Claude doesn't need to consume all those output tokens either.3️⃣ The clever part: HooksSpotify initially put these rules in CLAUDE.md.Problem?They're just instructions.Claude can ignore them.So shunt adds a hard gate:If Claude tries to fully read a file above a configurable threshold (350 lines by default), the hook blocks it and redirects Claude to the bulk-reader.Targeted reads still work.That's the important architectural lesson:Don't just tell an AI agent how to behave.Put enforcement around expensive behavior.Spotify's benchmark on a 162K-line Java monorepo reported:• 82% savings — single large file• 94% savings — source + test pair• 94% savings — multi-file analysis• ~90% mean savings across bulk-read scenariosThere are tradeoffs.❌ Don't delegate debugging❌ Don't delegate architectural decisions❌ Don't delegate precise editing❌ Small files may not be worth the extra latencyBut for repetitive I/O?Use a cheap model as the worker. Keep the expensive model focused on reasoning.This pattern goes way beyond Claude Code.It's essentially:Frontier model = reasoningCheap model = I/O + boilerplateHooks = enforcementThat's a much more interesting future for AI coding agents than simply throwing a bigger context window at the problem.Spotify's plugin is open source.Link in comments 👇Source: Spotify Engineering + Spotify's portal-ai-plugins repository.We're building 1% with AI - a community for people who want to go beyond simply using AI.We share practical AI workflows, tools, experiments, and ideas for builders, developers, founders & students.Follow 1% With AI if you want to learn how the 1% are actually using AI to build and work differently.Most people use AI. 1% use it to think, build and work differently.

When I was a kid, I had to memorize the battery percentage on my mom’s laptop so that I could learn to code. I’d wait for my parents to go to bed, borrow it, and work on whatever I was building. Before returning it, I’d charge it to the same percentage and put it in exactly the same spot.My parents gave me 1 hour of screen time per day. So I coded in secret, sleeping every alternate night through middle school and high school. All for this one obsession: making computers understand us like humans do.It started with Iron Man. I wanted to build Jarvis, so I taught myself to code through YouTube tutorials. Then came games, music apps, productivity tools. Each project gave me another reason to learn a language or figure out a new platform.That’s what got me hooked on engineering. You can have an idea, teach yourself what you need, and make something that other people get to use.I’m still working toward that original idea at Wispr: making computers feel natural to talk to.18 years later, sitting at a laptop in the middle of the night still takes me back to that kid with a dream to build Jarvis.At least I can leave the battery at whatever percentage I want now.

I just read LangChain's new whitepaper, "The Agentic Operating Model". Clearest write-up I've seen on why shipping agents is an organizational problem before it's a technical one.Three takeaways:- The classic Software Development Life Cycle doesn't transfer. Deterministic code gives you unit tests and stack traces. Agents give you eval suites and complex traces analysis. Versioning stops being only code commits and adds prompts, models, tools and datasets.- Builders come in three rings: platform engineers who own the substrate (I'm currently inside this ring), agent engineers who ship domain agents on it, and non-technical builders (SMEs, ops, support) who should own prompts, eval criteria and ground truth (but rarely do). Most enterprises staff rings 1 and 2 properly and forget to put ring 3 in the loop, which is exactly where the domain knowledge lives.- Governance is not a review board. Cost, tool access and discoverability only hold if each maps to an enforcement point in the stack: an LLM gateway for spend and PII, a policy engine for tool calls, a prompt/tool/skill registry so teams stop rebuilding what already exists.The number that stood out to me: "iteration and governance can absorb more than 80% of agent funding". If you are not systematizing the "failure -> root cause -> fix -> re-eval" loop, that is where your budget goes.To automate this loop, you can set up an agent that analyzes production traces, clusters failures, proposes fixes, and adds new evaluators and dataset examples to avoid future regressions. LangSmith Engine does exactly this.Worth reading if you run an internal AI platform: https://lnkd.in/eHGqUNHs

Turn any codebase into an interactive knowledge graph!Understand-Anything is a Claude Code plugin that builds an explorable map of your project. It analyzes every file, function, class, and dependency, then gives you an interactive dashboard to explore it all visually.Run the analysis and five agents execute in parallel. They scan your project, extract structure, identify architectural layers, and build a knowledge graph. The output is an interactive React Flow visualization.The dashboard shows your codebase as a graph. Nodes are files, functions, and classes. Edges show dependencies. Everything is color-coded by layer (API, Service, Data, UI, Utility).Click any node to see its code, relationships, and a plain-English LLM explanation.Key features:• Visual exploration with searchable, interactive graph• Plain-English summaries for every component• Guided architecture tours ordered by dependency• Semantic search - find by meaning, not just name• Diff impact analysis - see what your changes affectIt works across multiple AI coding agents - Claude Code, Codex, OpenCode, OpenClaw, Cursor, AntigravityIt's 100% Open source

Booking.com released a guide on how they evaluate every single AI app they build.Evaluating LLMs in prod is a different game than evaluating traditional ML models.- Golden datasets matter: human-annotated data is still the foundation for building trustworthy judge-LLMs. Without reliable labels, automated evaluation breaks down.- Annotation protocols are key: whether you go with a single annotator (basic) or multiple with consensus/weights (advanced), the consistency of annotation directly impacts evaluation quality.- Judge-LLM can't be the same as target-LLM: a stronger LLM can be used to evaluate the outputs of another, allowing scalable and automated monitoring of GenAI systems.- Pointwise vs. comparative judges: pointwise scoring works for production monitoring, but comparative evaluation (A vs. B) often provides stronger signals for ranking and system improvement.- Automation + synthetic data are emerging directions: auto-prompt pipelines and synthetic golden datasets could significantly reduce the time and cost of judge-LLM development.♻️ Share it with anyone who might benefit :)I regularly share AI Agents and RAG projects on my newsletter 𝑨𝑰 𝑬𝒏𝒈𝒊𝒏𝒆𝒆𝒓𝒊𝒏𝒈 𝑾𝒊𝒕𝒉 𝑺𝒂𝒓𝒕𝒉𝒂𝒌: https://lnkd.in/gaJTcZBRLink to full article: https://lnkd.in/g3-qWFhB