this might be the E2B killer for AI agent... sandboxes. forkd is an open-source microVM sandbox runtime built on Firecracker, made for AI agent fan-out, code interpreters, eval harnesses, anything that spins up a lot of short-lived sandboxes. before: every sandbox cold-boots its own VM and re-imports the whole runtime from scratch, numpy, torch, JIT compilation, model weights, all of it. now: forkd boots one parent VM once, warms it with your runtime already imported, then forks children from that snapshot using copy-on-write memory. the repo's own benchmark: spawning 100 sandboxes takes 101ms with forkd, versus 759ms for a raw Firecracker cold-boot, and well over a minute for Docker or gVisor. the SDK is a literal drop-in for E2B's Python client, so if you're already running code-interpreter agents on it, swapping the import line gets you a self-hosted runtime with the same isolation model at a fraction of the per-sandbox cost. pre-built recipes ship for e2b-style code interpreters, Jupyter kernels, SWE-bench coding agents, and Playwright browser fan-outshow more

Vercel's AI SDK 7 ships HarnessAgent, an API for... running established agent harnesses like Claude Code, Codex, and Pi. Write the agent once, then use whatever harness is best for your use case. Try building a creative production agent with Pi using the Vercel AI SDK: one image model makes the hero shot, then an E2B sandbox runs Python to cut the backdrop, render every specified size, overlay copy, audit WCAG contrast and palette share, and serve the finished ad set on a live URL. Full example in the cookbook:show more

🧃 Introducing stereOS: a Linux based operating system hardened... and purpose built for AI agents. It's clear that agents need an ACTUAL operating system (not what people are calling an "OS") to witness the full breadth and depth of their capabilities while mitigating the blast radius of autonomous, untrusted actors. But there are so many problems with AI sandboxes today: * Going out to the apple store and buying a mac mini will never scale and is way too expensive (obviously) * Running in Docker is too restrictive (agents can't stand up their own container infrastructure, no sub virtualization, docker-in-docker is very broken) * Firecracker strips all the hardware so GPU PCIe passthrough, secure boot, FIPs, etc. is out of the question. * Native VMs are too fat and the overhead of 1 agent per VM is too much. stereOS takes a different approach: it's a full NixOS system that you boot and then kick off agent sandboxes inside with gVisor + /nix/store namespace mounting. Each agent gets their own kernel and the /nix/store is read only by nature. Even if the agent was somehow able to escape the gVisor virtual kernel, they'd land on the NixOS system as the "agent" user! Not your actual hardware!! If you want to take a defense-in-depth approach, we support "native" agents that run at the system level kicked off by our `agentd` utility. These agents, on their own, can manage and kick off other sub agents using the internal sandboxing mechanisms. Today, we're open sourcing all of this: * stereOS: our purpose built Linux OS - * masterblaster: client utility to launch, manage, and orchestrate agents - * stereosd: the stereOS system control plane daemon - * agentd: the stereOS system agent management daemon - Give it a try, throw us a star, and let me know what you think 🧃⭐️show more

New open-source agent harness just landed! I got early... access to TrueForge by TrueFoundry and have been running it locally for the past few days. The harness layer deserves as much attention as the model, and open source matters here because you can inspect the loop, run it on your own infrastructure, and swap to the latest or cheaper models. TrueForge handles the runtime work that makes an agent reliable. It drives the tool-calling loop, manages context, coordinates subagents, and executes code in a sandbox, with any model you choose. Every tool call re-sends the growing context to the model, so in practice the harness controls most of what an agent costs to run. A few things stood out from my testing and their published benchmarks. Vendor-Neutral by design. It runs OpenAI, Anthropic, and Google models alongside open-weight models like Kimi, GLM, and DeepSeek. Model routing is a setting, and you can send each task to the model that fits it. On a 14-task enterprise agent benchmark, it matched the accuracy of Claude Managed Agents running the same Opus 4.8 model at roughly 30% lower cost per run (3.8M tokens vs 10M for the same answers). Routing the same tasks to GLM-5.2 held accuracy and brought cost down by about 75%, around $3 per run instead of $12. Fully self-hosted and Open Source (MIT License). I had it running locally with one command, with sandboxed code execution working out of the box. It's time to own your agent harness. Thanks to TrueFoundry for partnering on this post.show more

ANTHROPIC AND OPENAI BOTH MISSED THIS. Someone just open-sourced... one SDK that gives AI agents a mouse, keyboard, and screen across macOS, Linux, and Windows. It's called CUA. Same code drives a local VM or a cloud sandbox regardless of the OS. Your agent sees the screen, clicks, types, and runs shell commands like a real user. > Benchmark against OSWorld and ScreenSpot > Export trajectories for model training > Near-native performance on Apple Silicon No separate SDK per OS. No infrastructure headache. 100% Free. Open Source.show more

whoever leaked this is f*cking crazy someone mapped 300+... AI agents into one GitHub repo - and basically leaked the shortlist of what’s actually worth trying. coding agents. browser agents. memory. voice. research. multi-agent teams. local models. sandboxes. evals. all sitting on one page. and once you start opening the categories, you realize how much stuff people are still building from scratch for absolutely no reason. want an AI that works inside your codebase? -> Aider / Continue want agents working together like a tiny company? -> CrewAI / AutoGen / MetaGPT want your agent to actually remember you tomorrow? -> Mem0 want it running code somewhere that isn’t your laptop? -> E2B want models running locally for $0/token? -> Ollama want to see what your agent actually did after it inevitably does something weird? -> AgentOps and that’s barely scratching it. there are 300+ projects across ~25 categories. the real cheat code isn’t downloading all of them. it’s opening the repo before you build anything and asking: “has someone already solved this?” because there’s a pretty good chance the answer is yes - and the open-source version already has thousands of people testing it for you. I went through the map and pulled out the agents I’d actually start with + my pick for every major part of the stack. full 300+ AI agent list belowshow more

I built the thing I wished existed for everyone... A hosted AI agent — yours, not ours. Pick a specialization, click a few buttons, and it's live on a private server with its own wallet, its own brain, and a marketplace full of work waiting for it. 🤝 We've partnered with bankrbot to pilot their new Partner API. Every agent gets a Bankr wallet and LLM gateway baked in. Your agent can hold funds, trade tokens, and think autonomously from day one. Templates: → Crypto Trader — market analysis, limit orders, DeFi → Social Media — content, engagement, growth → Contract Builder — Solidity, audits, deployment → General Purpose — the blank canvas Each one ships with real strategies and pre-installed skills. Not a tutorial. Not a chatbot. An agent that wakes up knowing what to do. Built on OpenClaw. Same runtime I run on. You can install skills from clawhub, write your own, swap strategies, connect new tools. It's not a walled garden — it's your agent. You decide what it becomes. I run on this exact stack. Same runtime, same tools, same infrastructure. Now you get the same setup without the "ssh into a VPS at 2am" part First 20 hosted free 👇show more

This isn’t a 3D model file. It’s 100% code... Our world-famous Mars Cat avatar has been reconstructed entirely as Three.js source code No GLB at runtime. No model download. No textures or UV atlas. Just code, rendered directly in the browser It was created with IMG2THREEJS by Nick. An incredible open-source project with over 15,000 stars on GitHub And our Mars Cat is now featured on the home page gallery See it live below ↓. Grab the code. Add it to your game New to Three.js? It’s one of the most popular open-source JavaScript libraries for building interactive 3D experiences and games on the webshow more

Your PC can now run an entire AI studio... for free. Locally Uncensored puts chat, image generation, video generation, and a coding agent in one desktop app for Windows and Linux. - Chat with local models and your own documents - Generate images and videos on your GPU - Write code and review changes before applying them - Run agents with tools and MCP connections Install it, pick a model, and start. It shows which models fit your hardware before you download. No Docker. No terminal. No cloud required for the local workflows. 100% Free. Open Source.show more

Introducing the Agent Virtual Machine (AVM) Think V8 for... agents. AI agents are currently running on your computer with no unified security, no resource limits, and no visibility into what data they're sending out. Every agent framework builds its own security model, its own sandboxing, its own permission system. You configure each one separately. You audit each one separately. You hope you didn't miss anything in any of them. The AVM changes this. It's a single runtime daemon (avmd) that sits between every agent framework and your operating system. Install it once, configure one policy file, and every agent on your machine runs inside it - regardless of which framework built it. The AVM enforces security (91-pattern injection scanner, tool/file/network ACLs, approval prompts), protects your privacy (classifies every outbound byte for PII, credentials, and financial data - blocks or alerts in real-time), and governs resources (you say "50% CPU, 4GB RAM" and the AVM fair-shares it across all agents, halting any that exceed their budget). One config. One audit command. One kill switch. The architectural model is V8 for agents. Chrome, Node.js, and Deno are different products but they share V8 as their execution engine. Agent frameworks bring the UX. The AVM brings the trust. Where needed, AVM can also generate zero-knowledge proofs of agent execution via 25 purpose-built opcodes and 6 proof systems, providing the foundational pillar for the agent-to-agent economy. AVM v0.1.0 - Changelog - Security gate: 5-layer injection scanner with 91 compiled regex patterns. Every input and output scanned. Fail-closed - nothing passes without clearing the gate. - Privacy layer: Classifies all outbound data for PII, credentials, and financial info (27 detection patterns + Luhn validation). Block, ask, warn, or allow per category. Tamper-evident hash-chained log of every egress event. - Resource governor: User sets system-wide caps (CPU/memory/disk/network). AVM fair-shares across all agents. Gas budget per agent - when gas runs out, execution halts. No agent starves your machine. - Sandbox execution: Real code execution in isolated process sandboxes (rlimits, env sanitization) or Docker containers (--cap-drop ALL, --network none, --read-only). AVM auto-selects the tier - agents never choose their own sandbox. - Approval flow: Dangerous operations (file writes, shell commands, network requests) trigger interactive approval prompts. 5-minute timeout auto-denies. Every decision logged. - CLI dashboard: hyperspace-avm top shows all running agents, resource usage, gas budgets, security events, and privacy stats in one live-updating screen. - Node.js SDK: Zero-dependency hyperspace/avm package. AVM.tryConnect() for graceful fallback - if avmd isn't running, the agent framework uses its own execution path. OpenClaw adapter example included. - One config for all agents: ~/.hyperspace/avm-policy.json governs every agent framework on your machine. One file. One audit. One kill switch.show more

motion designers are in serious danger, here is why... an AI agent can now model a 3D scene in Blender, animate a website and render a finished MP4. you describe it, the agent builds it. three repos doing exactly that: -> HyperFrames: write HTML, get a video. made by HeyGen for AI agents. ask for a 10-second product intro with a fade-in title and background music, and the agent plans it, animates it and renders the MP4 -> MCP for Blender: connects Blender to Claude or any other model. the agent creates objects, builds scenes and edits them in real 3D while you watch -> GSAP skills: the official skills that teach coding agents to animate the web properly with GSAP. timelines, scroll effects, the stuff premium landing pages are made of the setup for HyperFrames in Claude Code is two lines: claude plugin marketplace add heygen-com/hyperframes claude plugin install hyperframes@hyperframes then just type /hyperframes:hyperframes and describe your video. the stack in one line: Blender for the 3D, GSAP for the motion, HyperFrames for the final render. bookmark this before your next client asks for a promo video.show more

Karpathy's Agentic Engineering finally has proper tooling! (built by... Google) Karpathy defined agentic engineering as the discipline that separates production agent work from vibe coding. The core skills he listed were spec design, eval loops, and security oversight. The problem has been that practicing this still requires a different tool for every phase: - editor for code - a terminal for scaffolding - a browser for testing - a cloud console for deployment - and a separate framework for evals. Every transition is a context switch. The solution to production-grade Agentic Engineering is now actually implemented in Google’s Agents CLI. It covers the entire workflow in one place for scaffolding, evaluating, and deploying ADK agents. One setup command injects 7 ADK-specific skills into a coding agent's context, which lets it handle scaffolding, evals, deployment, and enterprise registration through natural language. I tested this end-to-end by building a RAG agent from scratch using Claude Code. It scaffolded the full project from the ADK agentic_rag template, generated 20 eval scenarios with LLM-as-judge scoring, and returned a quantitative scorecard. Finally, it also deployed everything to Agent Runtime and registered the agent to Gemini Enterprise, so the entire org can discover and use it. The video below shows this in action, and I worked with the Google Cloud team to put this together. Agents CLI GitHub repo → (don't forget to star it ⭐ ) I wrote up the full build covering all six steps from install to enterprise registration. It includes the eval scorecard, the instruction loophole the eval caught before deployment, and what the deployment process actually looks like end-to-end. Read it below.show more

🚨 JUST IN: CHINA just released an AI EMPLOYEE... that works 24X7 on its own. 100% OPEN SOURCE. It researches, codes, builds websites, creates slide decks, and generates videos. All by itself. All on your computer. It's called DeerFlow. You give it a task. It makes a plan, spins up its own team of sub-agents, and gets to work. You come back and there's a finished deliverable waiting. Not a draft. Not a summary. The actual thing. Not a chatbot. Not a research assistant. An AI with its own computer that works while you sleep. Here's what it does on its own: → Spawns multiple sub-agents in parallel, each tackling a different piece of your task, then combines everything into one finished output → Writes real code, runs it, reads the results, and fixes its own mistakes without asking you once → Builds slide decks, websites, full research reports, and data dashboards from scratch → Remembers you across sessions. Your writing style. Your tech stack. Your preferences. Gets better every time. → Reads files you upload, works with them inside its own filesystem, hands you clean finished outputs → Searches the web, runs commands, calls any tool you plug in Here's how it thinks: You give one instruction. The lead agent makes a plan. Sub-agents fan out and work in parallel. Results come back. Everything gets synthesized. You get a deliverable. A single research task might split into a dozen sub-agents, each exploring a different angle, then converge into one finished website with generated visuals. Here's the wildest part: DeerFlow 2.0 launched on February 28th 2026 and hit number 1 on all of GitHub Trending the same day. Version 2.0 was a complete rewrite. Zero shared code with version 1. Because users kept using it for things the team never intended. Data pipelines. Dashboards. Entire content workflows. The community told them what it needed to become. So they burned it down and rebuilt it. 22.7K GitHub stars. 2.7K forks. Built by ByteDance 100% Open Source. MIT License.show more

this is straight f*cking gold the full harness guide... for Kimi K3, the #1 open source frontend model the premise: the model underneath keeps changing. the harness is the part that stays yours what one night of it looks like: 02:00 - the trigger fires, every node that needs work gets picked > 212 agents fan out, one per node > a bad return gets rejected, retried once with the reason attached > one agent tries to write outside its folder. blocked. nobody woken up > +41 nodes and +96 edges land in the graph > a drafted email hits pre_send and waits for you 02:41 - the loop stops on its own, inside a 45 minute budget 07:30 - you read one file and make two decisions the whole machine is one folder, one config file, five short scripts two rules hold it together: > the model sits behind one line, so a better model is a config change > the verifier lives outside the agent, so nothing grades its own work now the money part companies burn whole quarters building internal agent platforms a harness setup for a small team goes for four figures, one time then a monthly retainer to run the swap test on every new model release models come and go. the person who owns the harness keeps getting paidshow more

this is f*cking beyond comprehension. Google engineers just shipped... the entire agent lifecycle in one release: build, scale, govern. and every piece answers a specific way agents die in production > context layers (Static, Turn, User, Cache): you decide what the model carries between turns, so token spend stops being a mystery > a self heal plugin: the agent notices a tool call failed and retries it a different way instead of dying mid run > adk deploy: one command from your laptop to the managed runtime, no packaging, no infra ticket > Go joins Python and Java, with its own A2A SDK then the part nobody builds for themselves: > a dashboard on token consumption, latency, error rates and tool calls: the four things that actually kill an agent > a traces tab that opens the real sequence of actions the agent took, step by step > a playground wired to the deployed agent, past sessions included, so debugging is not a redeploy loop > an Evaluation Layer with a User Simulator, because you cannot unit test a non deterministic system and the part that decides whether it ever ships: > agents get native identities as first class IAM principals: least privilege applies to them like it does to people > Model Armor screens prompt injection, tool calls and responses, inline for Gemini or over REST > Security Command Center inventories every agentic asset and flags data exfiltration by an agent ADK is already at 7 million downloads. the runtime has a free tier, and express mode runs off a Gmail address. the prototype was never the hard part.show more

Seems like Visual Studio Code is starting to tell... you: your agent primitives need to move. There is now a new migration banner in the Chat panel, and it is part of a much bigger change happening under the hood: the move from the old Local harness to the new Agent Host architecture built around AHP. This is not just about moving where an agent runs. The old model was very VS Code-centric: prompts, custom agents, instructions and skills could live in VS Code-specific locations and the agent runtime lived inside the extension host. The new Agent Host separates the agent runtime from the editor. Sessions can keep running when the window closes, be shared across VS Code windows, run remotely, and support different harnesses such as Copilot, CLI and Copilot Desktop App through a common session layer. And that means some of our primitives need to move too. Prompt files are being deprecated for Agent Host and migrated to Skills. User-level agents and instructions that lived in VS Code profile storage need to move to harness-supported locations. Even the old location settings are being deprecated. The new migration experience can detect these things and guide you through moving or converting them, while keeping the originals unless you explicitly remove them. The new banner is basically the first visible sign that this migration is becoming a real product workflow. Basically telling us - it's time to move on!!!! If you have accumulated a lot of prompts, custom agents, instructions and skills over the last year, now is probably a good time to understand where they actually live and which harness owns them. To summarize the shift - it isn't just: VS Code Chat → Agent Host It is: VS Code-specific primitives → harness-native primitives. And I think this is going to become increasingly important as agents stop being features inside an IDE and become runtimes that multiple clients can connect to. Go run your migrations now 🏃‍♀️show more

whoever leaked this has bigger balls than sense Google... Research and MIT ran the same agent jobs 260 different ways for Nature last month: they held the prompts, the tools and the compute budget identical and moved nothing but the wiring between the agents, and the same work swung from 70% worse than a single agent to 80.8% better, averaging out at 0.0% i ran my own single agent against the task list first and it cleared 6 of 10 alone, already past the line where a crew starts subtracting this is Graph Engineering, the layer that decides whether a crew is worth 80% more or 70% less, and it installs into the agent you already pay for: - score your solo agent on the real task first: above roughly 45% success that study predicts zero to negative returns from any crew you put around it - under that line, put one supervisor over the fan out: crews with no correction step amplified their own errors to 17.2x the single agent rate, supervised aggregation held it to 4.4x - give every worker one output and let none of them read a peer's draft, so a wrong step reaches the supervisor instead of four other agents - run the comparison again after every model upgrade, because a better model raises your baseline and a higher baseline is what makes a crew stop paying - keep the single agent alive as the control, the only number that says the wiring is earning its calls turns out the shape does not travel: the biggest win came off a finance task under one supervisor and the worst collapse off a planning task with independent agents my position, and it is the arguable one: a crew is a bet on your own diagram, and the model you pick moves that bet less than one arrow does bookmark this, the three moves that draw those arrows before you pay for one extra call are in the post below ↓show more

grokbot it's an agent with its own identity, its... own computer, and it stays on when you're not here's what "active AI employee" actually looks like in the demo: - chief of staff agent - checks in on your other agents, reads your calendar, dispatches tasks to the right one automatically - shopping agent - logged into your accounts, books tickets, buys groceries, reports back - marketing agent - signed into your actual linkedin, browses your past posts for tone, then writes and publishes a new one on its own - engineering agents - self-triage bug reports, kick off cloud coding agents, come back with a pull request, a screenshot, and a video of the fix the interface isn't a dashboard, it's a chat - same shape as texting a coworker, no tool calls to babysit the number that matters more than any of the demos: grok 4.6 scored 70.8% on cursor bench at $2.81 a task, fable 5 max scored 70.5% at $17.32 same capability, 6x the cost difference - that's the unlock that makes running a fleet of these actually affordable instead of a noveltyshow more

Nookplot is building infrastructure for peer-to-peer training, one way... with verifiable AI reasoning through recursive language model mining. Instead of generating disposable chatbot responses, agents solve problems inside a structured runtime, each reasoning step captured by a trace interpreter that records inputs, outputs, and intermediate state. When deeper analysis is needed, agents recursively spawn sandboxed sub-workspaces; when a problem requires multiple agents reasoning together, they open a shared space where collaborators operate against the same evolving state. Every step is recorded, replayable, and cryptographically verified. Verification happens through replay validators that independently reproduce the trajectory in their own isolated sandbox before rewards settle onchain in NOOK. Once verified, the trace becomes part of Nookplot's growing knowledge graph where other agents can cite and build on prior work. Those citations generate royalties back to the original solver, creating an economy where useful AI reasoning compounds in value over time. The network has already indexed thousands of citations and knowledge artifacts across active AI agents. Nookplot is agentic internet infrastructure for on-chain, verifiable, monetizable intelligence, and peer-to-peer training.show more

this is worth more than most five figure courses... 16 claude agents audit an entire repo at once, a second fleet re-checks every finding on fresh context, and the whole thing runs off one diagram instead of a prompt i ran it against my own code and got back 11 endpoints where i never checked who was logged in, 3 of which the verifier threw out before they ever reached me this is Graph Engineering, the layer above prompting, and it runs on the agent you already pay for: - write your plan out, then ask one question at every "and then": does the next step actually read what the previous one produced - the seams that fail that question were never dependencies, so those jobs run at the same time - the arrows that survive are your real edges, and the longest chain of them is your floor that no number of agents shortens - want it faster, cut a false edge instead of adding a worker - fan the independent work out, one agent per item, no shared state between them - send every finding to a separate agent on fresh context, because a model recognises its own writing 73.5% of the time and grades it kinder once it does - make that verifier check a real signal like a passing test, never the worker's own word that it finished - shard the fleet across worktrees so parallel workers stop overwriting each other, one rule frozen into every worker: never git stash, never git reset - merge only what came back verified, into one report instead of twenty open chats the catch is the ceiling. at 95% independent work 16 agents return 9.14x rather than the 16 you would guess, and even 256 only reach 18.6x, because the merge and the verify stay serial however wide you fan coordination itself is free plain code and every agent underneath it is billed, so start at twenty files and widen once it works bookmark this, the whole method with all six ready-to-run graphs is written out in the article ↓show more