Sumanth (@Sumanth_077)

Cloudflare open-sourced their own internal AI OS! Cloudflare OS is an AI productivity workspace originally built for internal use at Cloudflare. A large portion of their workforce - engineering, sales, and everything in between - uses it every day. They're open-sourcing it so others can fork and customize it as their own company OS. The core idea is a departure from how cloud software has worked for the past 25 years. When you create a slide deck in Cloudflare OS, you're not connecting to a shared SaaS app running on someone else's server. The system creates a private instance of slide deck software just for you, running in its own sandbox. They call these Gadgets. This has two direct consequences. First, a security bug in the slide deck app can't leak your slides to anyone else because your instance is completely isolated. Second, if the app is missing a feature you need, you can ask the agent to add it. And because you're running your own copy, it's safe to do so. The security model underneath this is called Gatekeepers. Each external resource connection gets a Gatekeeper that handles authorization, enforces narrow access to only what you intended, and logs every action for review. The genuinely interesting part is how Gatekeepers handle human approval. Most agent setups stop and wait for the human to approve each action before continuing - which is why people often end up using "dangerously-skip-permissions." Gatekeepers simulate the action locally instead, let the agent keep working, queue the real action, and let the human approve or reject in bulk later when convenient. Key capabilities: • Gadgets: private per-user instances of every app, sandboxed and AI-modifiable • Gatekeepers: async human-in-the-loop approval without blocking agent progress • Blueprints: shareable app templates where each user runs their own copy • Built-in coding agent that builds, tests, and debugs Gadgets • Real-time multiplayer collaboration via Durable Objects • Capability-based security - agents get access to nothing by default • Runs on Cloudflare Workers or self-hosted on workerd I've shared the link in the replies!

The distributed platform that powered Kimi K3's RL training! AgentENV is the infrastructure that powered agentic RL training for Kimi K3 - running thousands of isolated sandboxes simultaneously, each forkable, snapshotable, and resumable in milliseconds. Training agents with RL means running the same task across thousands of parallel environments. Each needs its own isolated sandbox where the agent can write code, run shell commands, and interact with the filesystem. Docker is too slow to start. Full VMs are too heavy. And at training scale, cloud sandbox costs compound fast. AgentENV uses Firecracker microVMs. Environments boot or resume in under 50ms and pause in under 100ms. When an agent finishes its turn and waits for the next update, the environment pauses and returns its memory to the host. When work arrives again, it resumes instantly from exactly where it left off. The fork capability is what makes parallel RL training practical. Instead of booting thousands of fresh VMs from the same base state, AgentENV snapshots one running environment and forks it into multiple independent sandboxes in under 100ms. Each fork is fully isolated. Agents try different approaches simultaneously without interfering with each other. Snapshots happen incrementally, completing in under 100ms even under heavy disk modification. They persist to S3-compatible object storage so no state is lost if a machine goes down. Local disk acts as a bounded cache, so images can exceed disk capacity without pre-warming every host. AgentENV also exposes an E2B-compatible HTTP API. If your agent code already uses the E2B SDK, point one environment variable at your AgentENV server and your existing code works without any changes. Key capabilities: • Firecracker microVM environments: boot and resume in under 50ms • Fork a running environment into multiple independent sandboxes in under 100ms • Incremental snapshots to S3-compatible storage in under 100ms • Memory ballooning returns idle guest memory to the host • Images can exceed disk capacity via overlaybd with on-demand loading • E2B-compatible HTTP API - drop-in replacement with no code changes • Distributed across machines via Kubernetes or Docker Compose 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!

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!

YC just open sourced their multi-agent harness! QM is the multiplayer agent harness Y Combinator built and has been running internally across accounting, legal, events, and engineering. They used QM to build QM itself. The starting point was a fleet of 50+ Hermes agents - one personal assistant per employee. Managing that many separate agents became complex. QM came from asking a different question: instead of one agent per person, what if a company had one harness that worked for everyone? Most agents are designed like personal assistants. QM is designed for teams. Each employee gets their own isolated workspace with scoped memory, files, permissions, crons, and a durable sandbox. Those workspaces also connect in shared Slack channels and projects where people and the agent work together. The same identity and configuration carries between Slack and the web app. Admin controls which harnesses and models are available org-wide. Pi, OpenCode, Codex, and Claude Code all drive the same core, so a deployment isn't tied to any single vendor. Background work runs while nobody's watching. Crons and webhooks trigger tasks across the org. Skills are scope-owned and shareable by grant, with admin-gated promotion to the whole organization. YC is direct about where it stands: it's an experiment, it's early, and it has bugs. Key capabilities: • Multiplayer: personal workspaces + shared Slack channels and projects • Works natively in Slack and on the web • Vendor agnostic: Pi, OpenCode, Codex, Claude Code all supported • Per-scope memory, files, keychain, permissions, crons, and durable sandbox • Background crons and webhook triggers • Shareable skills with admin-gated org promotion • Three security postures: Strict, Auto, Dangerous 100% open source. The multiplayer harness problem is real and QM is a solid approach to it. The other harness problem most teams haven't named yet is context quality - what actually flows into the harness from your organization's systems determines everything that follows. Wrote a detailed breakdown on exactly that. I've also shared the link to QM in the replies!

RAG system that skips HTML parsing entirely! PixelRAG is an open-source visual RAG framework that renders documents as screenshots instead of parsing them into text. Most RAG pipelines start by converting HTML to text. Tables flatten into unstructured rows. Charts disappear. Layout context is gone before the LLM ever sees it. The paper measured this directly: HTML-to-text conversion accounts for 36.6% of retrieval failures on SimpleQA. PixelRAG skips that step entirely. It renders pages as screenshot tiles using Playwright, embeds those tiles with a fine-tuned Qwen3-VL-Embedding model, builds a FAISS index, and passes retrieved images directly to a VLM reader. No text abstraction in between. Benchmarked across six datasets against the strongest text-based baselines: - SimpleQA: 78.8% vs 71.6% (+7.1 points) - NQ-Tables: 48.8% vs 42.5% (+6.3 points) - EVQA: +15.5 points - LiveVQA: +11.3 points One honest caveat from the authors: this requires Qwen3-VL-4B class models or larger to see the benefit. Smaller models trail text retrieval. The authors also recommend using PixelRAG as an enhancement layer alongside existing text systems rather than a full replacement. Ships with a pre-built Wikipedia index covering 8.28M articles across 28.1M screenshot tiles. A Claude Code plugin lets Claude take screenshots of any URL and reason over the visual content directly. Key capabilities: • Renders web pages, PDFs, and images as screenshot tiles via Playwright • Fine-tuned Qwen3-VL-Embedding model for visual retrieval • FAISS index for fast vector search • Pre-built Wikipedia index: 8.28M articles, 28.1M tiles • 3x token cost reduction via image compression • Claude Code plugin for direct URL screenshot and visual reasoning • LoRA fine-tuning support via pixelrag-train 100% open source. I've shared the link in the replies!

Turn any website into agent-ready data! Loop engineering is about designing systems that run agents autonomously. Instead of prompting your agent manually each turn, you write a loop that finds the work, hands it to the agent, checks what came back, and decides what happens next. Your job is to design the loop once and walk away. But loops that need live information from the web hit a real constraint. JS-heavy pages return empty content. Anti-bot systems return challenge pages. Login walls block access entirely. When the model gets weak context back, it still responds - just less accurately. Anakin is building the source-access layer underneath agents. URL Scraper turns any URL into clean Markdown, HTML, or structured content immediately usable by an LLM. Built for scale across 200M+ active websites globally, including a large chunk of Cloudflare and Akamai-protected pages. Authenticated sessions handle content behind login walls. Wire handles workflow-heavy sites. Login flows, navigation, form submission, report exports - all accessible through a stable API. Define the workflow once and Wire keeps it working as websites change. Key capabilities: • Clean Markdown, HTML, or structured output from 200M+ active websites • Built for difficult pages including Cloudflare and Akamai-protected sources • Authenticated sessions for content behind login walls • Wire for login flows, navigation, form submission, and export-based access • Useful for AI agents, RAG systems, finance intelligence, and vertical AI workflows I've shared the link in the replies!

Stop prompting AI agents. Design the loops that prompt them instead. This is the core idea behind Loop Engineering, a methodology for building automated systems that orchestrate your AI coding agents instead of prompting them manually. Boris Cherny, Head of Claude Code at Anthropic, puts it directly: "I don't prompt Claude anymore. I have loops running that prompt Claude and figure out what to do. My job is to write loops." A loop is an automated pipeline that runs on a schedule. It checks what needs to be done, prompts your AI coding agent with the right context, verifies the result, and either commits the fix or escalates to you. Then it runs again. This repo is a starter kit and reference guide for building these loops. Seven production-ready patterns, CLI tools to scaffold your setup, and documentation covering failure modes, anti-patterns, safety, and multi-loop coordination. The seven patterns: Daily Triage, PR Babysitter, CI Sweeper, Dependency Sweeper, Changelog Drafter, Post-Merge Cleanup, and Issue Triage. Each one ships with a starter kit, cadence recommendation, and token cost estimate. Three CLI tools handle setup. "loop-init" scaffolds skills, state, and budget files and prints your Loop Ready score. "loop-audit" checks how ready your setup is and suggests improvements. "loop-cost" estimates token spend before you run anything. Works with Claude Code, Codex, Grok, OpenCode, Cursor, and GitHub Actions. Key capabilities: • 7 production loop patterns with starters and token cost estimates • loop-init scaffolds your setup and prints a Loop Ready score • loop-audit scores readiness and suggests improvements • loop-cost estimates token spend per cadence • Failure modes, anti-patterns, and safety documentation included • Works with Claude Code, Codex, Grok, OpenCode, Cursor 100% open source. 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!

Managing AI coding agents across your team is messier than it looks! Claude Code, Codex, Cursor - each one connects to model providers separately, with its own configuration, its own spend, and no shared visibility across any of them. Let me explain why this becomes a real problem at scale. Every developer on your team is using different AI tools. Each tool talks directly to its own model provider. No one knows which team is spending what, on which model, through which app. Security policies that apply to one tool don't automatically apply to another. When a new tool gets added, the entire setup starts over. This is AI sprawl. And it compounds fast. Glean just launched AI Gateway to address this. It sits as a single layer underneath all your AI tools, Claude Code, Codex, Cursor, internal agents, and custom apps. Instead of each tool talking to model providers separately, everything routes through one place. Two components make up the system. The LLM Gateway centralizes model access, provider routing, spend quotas, and audit trails across every tool. The MCP Gateway standardizes which tools and actions AI systems can access, so you configure approved tool access once instead of reconfiguring every AI app separately. The end result: your developers keep using the tools they already use. The controls, observability, and policies sit underneath every interaction without changing the workflow. Key capabilities: • Single layer for model access across Claude Code, Codex, Cursor, and internal apps • Spend attribution by app, user, model, and provider • Consistent security policies across all AI surfaces • MCP Gateway for standardized tool access across AI systems • Audit trails for every model interaction I've shared the link in the replies!

There's a fundamental gap in every AI agent stack today! Agents can plan, reason, and call APIs. But the moment they need a tool that requires an account, a subscription, or an API key, autonomy breaks. A human has to step in. That's the gap x402 closes. HTTP 402 "Payment Required" was reserved in the original HTTP spec and never formally used. Coinbase formalized it as a protocol for agentic payments. When an agent hits an endpoint and gets a 402 back, it authorizes a payment in USDC on Base from its wallet, and the tool runs. No account, no API key, no human in the loop. Apify Actors are serverless programs built for web scraping, automation, and data extraction. Roughly 20,000 of them are now callable via x402 today. An agent can discover the right tool, pay for it per call, and keep going entirely on its own. Most x402 services today are single purpose-built endpoints. This opens an entire catalog of community-built web automation tools to any autonomous agent. Key capabilities: • Agents discover, pay for, and run tools autonomously • No account, subscription, or API key required • Payment in USDC on Base via x402 by Coinbase • ~20,000 tools callable via x402 today • Accessible via MCP server or "npx awal" CLI I've shared the link in the replies!

Google DeepMind just dropped the Gemma 4 Technical Report! Gemma 4 is a family of open-weight, natively multimodal models ranging from 2.3B to 31B parameters, covering both dense and Mixture-of-Experts architectures. The most interesting architectural decision is in the 12B model. Instead of separate vision and audio encoders, it uses a unified encoder-free design. The 550M vision encoder is replaced by a single matrix multiplication at 35M parameters. The audio encoder is discarded entirely. Raw image patches and audio chunks are projected directly into the LLM embedding space. No separate encoder pipelines, no memory fragmentation. The efficiency numbers are compelling. A 2.3B effective parameter model (E2B) roughly matches Gemma 3 27B performance with 10x fewer parameters. The quantized 12B fits in 7.65 GB. KV cache footprint is reduced by up to 37.5% through local-to-global attention ratios, positional encoding, and key-value reuse in global attention layers. The audio encoder shrank from 390MB to 87MB after quantization, a 78% reduction, with improved transcription and translation performance. Gemma 4 31B sits at rank 43 on Arena Text as of June 2026, the top open dense model on the leaderboard. Models ranked above it are all MoE architectures with significantly more total parameters. All models ship with a thinking mode that generates a reasoning trace before responding. Benchmark results in thinking mode for the 31B: AIME 2026 at 89.2%, GPQA Diamond at 84.3%, LiveCodeBench v6 at 80.0%, and a Codeforces Elo of 2150. I've shared the link to the report the replies! Also put together a complete guide on fine-tuning Gemma 4 locally with Unsloth. I've quoted the article!

The meta-harness for all your AI coding agents! Omnigent is an open-source orchestration layer that sits above your AI coding agents. Orchestrates Claude Code, Codex, Cursor, OpenCode, Hermes, and Pi through a single interface. Swap or combine harnesses without rewriting anything. The problem with using multiple coding agents: each lives in its own terminal, has its own setup, its own commands. When you want to switch or combine them, you start over. Omnigent removes that. One layer above all of them, consistent interface regardless of which agent is running underneath. Sessions follow you across devices. Start in your terminal, continue in the browser, pick it up on your phone. Messages, sub-agents, terminals, and files stay in sync across every surface. Multi-agent orchestration works within a single session. Point one agent at another's work. Delegate tasks in parallel across Claude Code, Codex, and Pi running in separate git worktrees, then route the diffs to a reviewer from a different vendor. All from one session. Policy enforcement runs at three levels: server, agent, and session. Approve before shell commands execute, cap spend, limit tool calls. Stacks consistently across every harness you plug in. Custom agents via YAML. Define your own with tools, MCP servers, and sub-agents. Two ship out of the box: Polly, a multi-agent coding orchestrator, and Debby, a dual-head Claude and GPT brainstorming agent. Key capabilities: • Orchestrates Claude Code, Codex, Cursor, OpenCode, Hermes, Pi, and custom agents • Sessions follow you across terminal, browser, and phone • Multi-agent collaboration within a single session • Policy enforcement at server, agent, and session level • Cloud sandboxes via Modal, Daytona, E2B, and Kubernetes • Custom agents defined in YAML with tools and MCP servers • Real-time team collaboration and session sharing 100% open source. I've shared the link in the replies! Been going deep on what the harness layer actually needs to look like for agents to work independently in production - identity, memory, proactivity, accountability, and the context layer that ties it all together. Wrote a detailed breakdown on this recently. I've quoted the article!

5 Open Source No-Code LLM, RAG and AI Agent Builders! 1. AutoAgent - A fully automated, zero-code framework. You simply state a high-level goal in natural language, and it handles the planning, task decomposition, and execution automatically. It effectively turns a prompt into a running agent system. 👉 Github Repo: 2. AnythingLLM The best all-in-one solution for internal tooling. It combines RAG, agent workflows, and document management into a single, self-hosted workspace. It is privacy-focused and designed for both technical and non-technical teams to build tools around their own data. 👉 Github Repo: 3. LangChain Open Agent Platform A specialized UI built on top of LangGraph. Instead of hiding the logic, it makes the agent's flow explicit with nodes and edges. This gives you granular control over routing, loops, and multi-agent coordination without needing to write the underlying graph code. 👉 Github Repo: 4. Sim A visual workflow builder with an AI Copilot. You design agent pipelines as executable graphs, but you can use the built-in AI to generate or modify the flows for you. It includes detailed execution tracing, making it much easier to debug complex chains. 👉 Github Repo: 5. Dify A production-ready platform that focuses on observability. It supports prompt management, complex RAG pipelines, and agent logic, but adds the runtime monitoring you need for real applications. If you are deploying to actual users, this is the standard. 👉 Github Repo: If you're going deeper on how these agents actually work in production, I wrote a detailed breakdown on independent agents recently - covering identity, memory, proactivity, accountability, and the context layer that ties it all together. I've quoted the article below