Train your own Decision model like Jev locally! Unsloth now lets you fine-tune models like Qwen, Llama, and Gemma into decision models that make bounded decisions instead of generating text. The model reads the input together with the questions and options you define, then a small decision head scores those options and returns the selected answer with probabilities. So instead of using a generative model for every routing, classification, policy, or evaluation decision, you can train a much smaller model specifically for the decisions your system needs to make. Training is done with LoRA, and the dataset format is simple: input state, the questions to decide, and the gold answers. Unsloth also calibrates the model on held-out data, so the returned probabilities are meant to better reflect how often the model is actually correct. The reported results are pretty interesting. Qwen3.5-0.8B reached 78% holdout accuracy using around 4GB VRAM, while Llama 3.2 3B reached 79% at around 4.1GB VRAM. Qwen3.5-0.8B also improved from 36% to 73% on typed decisions after fine-tuning. Key capabilities: - Fine-tune Qwen, Llama, Gemma, or other supported LLMs into decision models - Train locally with 4-bit LoRA and relatively low VRAM - Handle choice, yes/no, and scored decisions in the same model - Return probabilities for each decision instead of generating free-form text - Calibrate the trained model on held-out data before serving it The part I like here is that you no longer need a purpose-built decision model to experiment with this architecture. You can take an existing open model, fine-tune it for your own decision space, and run the whole thing locally. I’ve shared the full Unsloth guide in the comments! I also built a data analyst agent with Jev as the review layer, and I’ve shared the full breakdown in the article below.

Your document agent is only as good as the parse behind it! I've built a Grounded Document Agent that answers questions across long PDFs, attaches citations to every response, and lets you inspect the exact source behind those citations. A lot of document-agent failures look like retrieval problems, but the damage often happens much earlier. If a PDF table is flattened incorrectly, a chart loses structure, or the reading order breaks, better embeddings cannot recover what was already lost. For this project, I used LlamaParse to convert PDFs into layout-aware Markdown while preserving page metadata. From there, LlamaIndex handles indexing and retrieval, while Ollama runs the embeddings and the local "qwen3:4b-instruct" model. For every question, the agent retrieves the most relevant sections, generates an answer with numbered citations, and lets you inspect the exact source text and page behind each citation. That matters because a citation does not automatically make an answer correct. If the underlying evidence was parsed incorrectly, the model can still cite the right page and give you the wrong answer. The useful part is being able to trace the answer through parsing, retrieval, and generation instead of treating a confident response as the final truth. PDF → LlamaParse → Local retrieval → Local LLM → Grounded answer with citations Here’s the complete project: I’ve also written a detailed article explaining how to build the complete grounded document agent step by step.

Build Voice AI agents locally! HuggingFace's speech-to-speech is a fully modular voice agent pipeline that runs entirely on open-source models. Every component is swappable and every stage runs in its own thread connected by queues. The pipeline exposes an OpenAI Realtime-compatible WebSocket API. Any existing OpenAI Realtime client can point at this server instead of OpenAI by changing one URL. Here is how it works: 1. Voice Activity Detection - Silero VAD v5 detects speech boundaries and turn-taking 2. Speech to Text - transcribes the user's turn with optional live partial transcripts 3. Language Model - generates the response, streaming text and tool calls 4. Text to Speech - synthesizes audio and streams it back to the client Every stage has multiple interchangeable backends you can select via CLI flags. For a fully local setup, run Gemma 4 via llama.cpp alongside the pipeline with Parakeet TDT for STT and Qwen3-TTS for speech output. No API keys needed. Key capabilities: • OpenAI Realtime-compatible WebSocket API - drop-in replacement • Fully local with no API keys via llama.cpp + Parakeet TDT + Qwen3-TTS • STT: Parakeet TDT, Whisper, Faster Whisper, Paraformer • TTS: Qwen3-TTS, Kokoro, Pocket TTS, ChatTTS, MMS TTS • Multilingual with automatic language detection • Four run modes: Realtime, Local, Raw WebSocket, TCP Socket 100% open source. I've shared the link in the replies!

Andrew Ng open-sourced an AI coworker! OpenWorker is a desktop app that delivers finished work, not just chat. You describe the outcome you want - a customer brief, a triaged inbox, a calendar update, a release status across Jira and GitHub - and it works across your files, terminal, and connected apps to produce the actual deliverable. The design principle: it reads freely but writes only after you approve. Before anything consequential - sending a message, making a calendar change, running a shell command - it pauses and shows you exactly what it's about to do. Unattended scheduled runs park approval-needed actions in an inbox rather than acting on their own. 25+ integrations out of the box: GitHub, Slack, Jira, Notion, Linear, HubSpot, Gmail, Google Calendar, Outlook, monday, and your terminal and local files. Any MCP tool plugs in too. Works from Slack directly. Mention @ OpenWorker in a channel, the work happens on your desktop with your tools, and the answer comes back as a thread reply. Bring your own model. OpenAI, Anthropic, Google Gemini, DeepSeek, Kimi, Qwen, MiniMax, Mistral, Grok, and fully local via Ollama. Everything runs on your machine with your own API keys. Built on aisuite, Andrew Ng's own unified LLM provider library. Currently in open beta on macOS and Windows. Key capabilities: • Delivers finished deliverables: documents, reports, Slack replies, updated calendars • Approval-gated writes, sends, and shell commands • 25+ integrations including GitHub, Slack, Jira, Notion, Gmail, and MCP tools • Scheduled automations for recurring work • Works from Slack via @ OpenWorker mention • Bring your own model: any provider or fully local via Ollama • Local-first: everything runs on your machine OpenWorker shows what happens when you get the loop right. Define the goal, the agent executes autonomously, approval gates control what runs. That's loop engineering in practice. Wrote a full breakdown on how to design loops you can actually trust to run without you. I've shared the link to the Github Repo in the replies!

Every API call gives you a choice: wait for the result now, or collect it later. Agentic Document Extraction (ADE) works both ways when you run a Parse or Extract. The first way is synchronous. You send the request and wait on the line until the result comes back. Simple, and right when someone needs the answer immediately. The second is asynchronous. You submit the work, get a ticket, and pick up the result once it is done. Nothing sits waiting on an open line. The result is identical either way. Same Markdown from Parse, same fields from Extract. You are only choosing how long you wait. So why ever hand it off? Two reasons. Big jobs need it. A single asynchronous Parse Job takes files up to 1 GB or 6,000 pages, far more than one live request can hold. It also costs less. Waiting on the line runs at the top rate, since something is blocked on it. Hand the job off and you drop to a cheaper tier for the same result. The rule of thumb is one question. If a person or an agent is waiting on the answer, run it synchronously. If nothing is waiting, submit a job and pay less. Full breakdown, plus the service tier companion, in the comments.

Stop optimizing tokens. Index your context instead! Retrieval quality is the foundation of context engineering. Karpathy described it best: the heavy cognitive work should happen at ingestion, not at query time. When knowledge is properly structured before retrieval, the model's job becomes reasoning, not sorting. Most AI systems focus on compressing what the model sees. The more important problem is what gets retrieved before the model sees anything. Token efficiency starts at retrieval. When context is properly indexed and prepared, the model spends its tokens on reasoning. When retrieval is weak, the model spends those same tokens sorting through noise and filling gaps from its own weights. That's the silent failure mode. Retrieval returns topically correct but incomplete context. The model completes the gaps from parametric knowledge and streams it out the same way as grounded content. No signal in the output tells you which parts came from retrieved context and which came from weights. The answer looks confident. It just isn't complete. The common assumption is that hallucination is the main failure mode. It's not. Models handle off-domain questions reasonably well now. If nothing in the retrieved context looks relevant, there's no material to build an answer on. The harder failure is partial coverage. The right document was retrieved. But not the full picture. Coverage gaps don't produce error messages. They produce confident answers with pieces missing. This gets worse when sources stay isolated. The same person might appear across multiple tools and systems. If those sources are indexed separately, the model has to figure out they refer to the same entity on its own. That's work that should happen before the model starts reasoning. Glean's system of context is built around this problem: • Unified index across all connected applications, not each source kept separate • Specialized indexes for different types of information: company data, code, experts, profiles, tools, and calendars • Multiple retrieval methods - semantic when meaning matters, lexical when exact terms matter, structured when fields and relationships need to stay intact • Enterprise Graph that maps relationships across people, teams, customers, and projects so relevance reflects how the company actually works • Memory that carries context forward across sessions and tasks • Tools that let the model act on what it finds The gap between finding information and understanding it is where most AI systems fall short. I've shared the link in the replies!

Open-source framework for building real-time voice AI agents! Pipecat is a Python framework for orchestrating audio, video, AI services, transports, and conversation pipelines. Voice-first architecture with pluggable components. What you can build: voice assistants, AI companions, multimodal interfaces, interactive storytelling, business agents (customer support, intake), and complex dialog systems. The framework handles speech recognition, text-to-speech, conversation logic, and real-time interaction. WebRTC and WebSocket transport built in. Ultra-low latency for natural conversations. Why Pipecat: • Voice-first: Integrates STT, TTS, and conversation handling in one framework • Pluggable: Supports multiple AI service providers for each capability • Composable pipelines: Build complex behavior from modular components • Real-time: Low-latency interaction with streaming audio/video Supported services: • Speech-to-Text: Deepgram, AssemblyAI, OpenAI Whisper, Groq, Azure, AWS, Google, and more • LLMs: OpenAI, Anthropic, Gemini, Groq, Mistral, Ollama, AWS, Azure, and more • Text-to-Speech: OpenAI, ElevenLabs, Deepgram, Cartesia, Azure, AWS, Google, and more • Speech-to-Speech: OpenAI Realtime, Gemini Multimodal Live, AWS Nova Sonic, Ultravox, Grok Voice Agent I've wrote a detailed tutorial on building a production customer support voice agent recently - covering turn detection, interruption handling, telephony codecs, and how to inject live business context into every call. I've quoted the article!

The model humans prefer the most is not always the most accurate one! Arena just added factuality scoring to their leaderboard alongside human preference. The idea: human preference measures whether a response felt good to read. Factuality measures the correctness of claims in a model's response. These are two different things. Most benchmarks test models on fixed, predetermined questions in a lab setting. What Arena is doing differently: measuring factuality in real, open-ended user conversations at scale. Over 2 million claims extracted from actual conversations, verified against the web, across 130k Text Arena battles and 40k Search Arena battles. The way it works: they randomly sample battles, extract web-verifiable claims from each model response, verify them against the web, and calculate a factuality score per model. The final ranking is a weighted combination of human preference and factuality score. When factuality weight is enabled, the shifts are significant. In Text Arena, GPT-5.5 jumps 13 spots. Muse Spark drops 13. Claude Fable 5 moves down slightly. In Search Arena, GPT-5.5-search takes the top spot while Gemini grounding drops from 7 to 13. I've shared the full methodology blog in the replies!

Pytest for Google ADK agents! Testing AI agents is fundamentally different from testing regular code. There's no single output to assert against. Every run can produce a different response. And when something goes wrong, it's rarely obvious which step caused it. AI agents built using Google ADK run across multiple steps. A model call plans the action. A tool executes it. Another model call generates the final response. Any of these can quietly go wrong without an obvious error. DeepEval is an open-source LLM evaluation framework, for evaluating large-language model systems. DeepEval's Google ADK integration brings Pytest to this problem. One call to "instrument_google_adk()" and every agent run is automatically traced. Every model call, tool invocation, and agent step becomes a component span you can evaluate independently. Testing works at two levels. End-to-end evaluation scores the full agent run on task completion. Component-level evaluation attaches metrics to individual LLM calls or tool spans, so you know exactly which step failed when a test breaks. The pytest integration works the same way as any other DeepEval framework. Parametrize your test with Goldens, run the agent inside the test function, call "assert_test()" at the end. A failing metric fails the test, which fails the build. Run it with "deepeval test run". You can also run evals outside CI. Loop through Goldens in a script, run the agent, and score each resulting trace without touching pytest at all. Key capabilities: • Auto-instrumentation with one function call • Trace, agent, LLM, and tool spans all independently evaluable • Native pytest integration with assert_test() for CI/CD • Metrics: TaskCompletion, AnswerRelevancy, Faithfulness, G-Eval and more • Script-based eval outside of CI • Optional Confident AI dashboard for trace visualization 100% open source. I've shared the link in the replies!

3x Model：GPT-5.6 Sol、Terra、Luna 5x Effort：Light、Medium、High、Extra High、Ultra 2x Speed：Standard、Fast ChatGPT Work and Codex 里，有 30 种不同的搭配方式！！！怎么选呢？总不能每个任务都把模型和强度、速度都拉满吧，额度也不够用啊？！ 看看 OpenAI Developer 最新发布的 GPT-5.6 最佳实践和迁移指南，从官方指导找一些确定性规则： 先看 GPT‑5.6 模型的三个等级 · gpt-5.6-sol：旗舰能力 · gpt-5.6-terra：能力与价格之间的平衡 · gpt-5.6-luna：面向高吞吐、效率优先的工作负载 对于推理强度 如果你之前用 GPT-5.5 或 5.4 已经有常用的推理强度，在使用 GPT-5.6 时，可以尝试： · GPT‑5.6 与相同推理强度 · GPT‑5.6 与低一档推理强度 原因是 GPT‑5.6 可能用更少 token 达到相同或更好的效果。但这只是需要验证的可能性，并非保证。medium 是标准和 Pro 模式的默认平衡点；high、xhigh 和 ultra/max 只应在真实评测显示质量提升时使用。 “更短的提示词”不是“少给必要信息” OpenAI 报告，在其内部评测中，将冗长系统提示词缩减为更精炼的版本，分数提高约 10%–15%，总 token 减少 41%–66%，成本减少 33%–67%。但这是厂商内部评测，没有披露完整任务构成、样本规模和评测方法，因此不应直接外推到所有业务。 应该保留的是：目标、必要背景、关键约束、授权边界、所需证据、成功标准和输出格式。 要处理长期堆积的提示词债务，例如： · 重复表达同一限制； · 大量已经成为模型默认行为的指令； · 不必要的角色设定和风格示例； · 与当前任务无关的工具； · 冗长但不精确的工具描述。 模型越主动，权限边界越应清楚 GPT‑5.6 更擅长推断用户意图，也更主动、持续。但“更懂意图”并不等于可以省略关键边界。 文档建议明确区分： · 回答、解释、审查、诊断：可以检查材料并报告结果； · 修改、构建、修复：可以执行范围内的本地改动和非破坏性验证； · 外部写入、删除、购买、发布或明显扩大范围：必须确认。 深层含义是：授权规则已经不只是提示词风格，而是智能体系统的安全接口。 不必在每段提示词里反复写“先询问”，但需要一次性把可自主动作和确认边界定义清楚。