Click any tag below to further narrow down your results
Links
Vercel has launched Board, an experimental, harness-agnostic message store that lets teams of AI agents claim tasks, post updates, and hand off work, with two-way sync to tools like Slack and GitHub. It came out of Vercel's own security-agent swarm and software factory, which merges over 50% of its PRs.
- Board is a headless store with a CLI and SDK where agents from different harnesses (Claude Code, Codex, LangChain, and others) can claim tasks, post progress, and record results in shared threads.
- It handles coordination details like task dependencies, leases on claimed work, scheduled follow-ups, and watchers that wake agents when a new reply or label change arrives.
- Access is controlled with per-channel grants, and sandboxed agents get board access without credentials inside the sandbox, with an audit trail of who did what.
Nous Research's open-source Hermes Agent is now available inside Microsoft Teams, the Microsoft Store, and Azure, aimed at companies that want a self-improving agent for every employee. The pitch is that successful workflows get saved as reusable skills the whole team can use.
- Hermes Enterprise runs in Microsoft Teams, Hermes Desktop for Windows (via the Microsoft Store), and Azure Container Apps Sandboxes, where agent tasks run in isolated microVMs that start in under a second.
- Hermes turns a successful approach to recurring work into a reusable skill, and a Collective Wisdom feature lets employees review and publish those skills for their team.
- Companies with strict data residency or procurement needs can run Hermes in their own Azure tenant.
The author argues that the surge in security incidents and AI-written code calls for engineering fixes rather than more AI, and walks through using Nix to patch the whole stack from one source of truth. The core idea is that agents make open-source dependencies less necessary, and that Nix overlays let you route around upstream bugs without waiting for maintainers.
- Agent-written code trained on existing vulnerable code is driving a "security take-off," and defenders may need more inference capacity than attackers to keep up.
- Open-source libraries existed because code was costly to write; with agents, the author uses far fewer and prompts for small, purpose-built code instead, reducing Dependabot and supply-chain churn.
- Nix can act as a single source of truth for laptops, CI, agent sandboxes and production images, and lets you monkey-patch tools like git (removing force push) across every environment at once.
A LinkedIn post from MotherDuck describes how data engineer Nick Ursa's job changed once business users started answering their own data questions with AI agents. His role is now to build the frameworks and data model that make those self-serve answers trustworthy, especially when they reach the board.
- Ticket queues have mostly disappeared; business users now answer questions themselves with agents, and the data engineer decides how much checking each answer needs.
- The new role, which MotherDuck's CEO Jordan Tigani calls "data intelligence engineer," covers building frameworks, curating context, running evals, and fixing things when they break.
- Commenters argue that the real burden is tracing and eval layers, because failures in agent-driven data pipelines often break silently.
@joshva_jebaraj on X
The poster recommends Harvard's CS2680 course as a solid way to learn how AI agents work. The course covers how Claude Code operates, how to build your own agent, and how to serve large language models on GPUs.
- The course explains how Claude Code works under the hood.
- It walks through building your own AI agent from scratch.
- It includes serving LLMs on GPUs, the infrastructure side of running models.
This is the documentation for Antigravity's /swarm command, which spins up a coordinator plus named worker agents that split a task, work on separate files in parallel, and communicate through a shared message board. A dedicated verifier agent reviews diffs and runs tests before results reach you.
- A coordinator divides the task into non-colliding pieces and assigns named workers (like @parser or @api-tests), with a verifier added for every two to four workers.
- All communication goes through one shared board rather than private messages, and idle workers sleep without using tokens until mentioned.
- Workers share the workspace by default, but the coordinator can give each its own repository copy; removing a worker deletes that copy, so changes must be landed first.
- Monitoring is available in the App's Swarm pane (Board, Members, Graph tabs) and the CLI's live board with keyboard navigation.
Google is rolling out Gemini 4 Carbon, its most capable model, aimed at hard tasks like multi-step coding, scientific research, and cybersecurity work. It costs more to run than the lighter Gemini 4 Argon, but Google says it's cheaper per task than competing top models on several benchmarks.
- Priced at $2 per million input tokens and $10 per million output tokens, the same introductory rate as Argon, and Google claims more than 2x lower cost per task than the next best external model on CursorBench 4.0, WANDR, and AutomationBench.
- Google previews /swarm in Google Antigravity, which coordinates multiple agents with Carbon handling architecture and auditing while lighter models do parallel work.
- In cybersecurity, Google reports Carbon found 0-day vulnerabilities in two major SaaS providers in under two hours, though these claims come from Google and its partners rather than independent testing.
Meta is releasing Muse Ember, a small, low-cost model aimed at the repetitive work agents do constantly, like tool calls, coding subtasks, and document extraction. The company claims it beats comparable Claude and GPT models on cost-per-task efficiency, with benchmark numbers that are mostly Meta's own or from Artificial Analysis.
- Priced at $0.10 per million input tokens and $0.50 per million output, with a 1M-token context window, and Meta puts its cost at roughly $0.14 per Artificial Analysis task.
- On the benchmarks Meta highlights, Ember leads Claude Haiku 5.5 and GPT-6 Luna on agentic tasks like AutomationBench (37.8% vs 13.9% and 20.2%) and Terminal-Bench (40.9% vs 39.2% and 16.4%), but it trails Haiku on FrontierCode 2.0 (27.2% vs 34.9%).
- Several headline comparisons come from Meta's internal evals, such as the Personal Superintelligence Index and OSWorld 2.1, so they are harder to verify independently than the Artificial Analysis numbers.
@cursor_ai on X
Cursor now lets you describe an app, have its agent build it, set up a database, run security checks, and deploy it to a shareable link. The pitch is aimed at the gap where AI-written code often never leaves localhost.
- Describe the tool you want and Cursor builds it, including the database setup.
- Deployment comes with both deterministic and agentic security checks before the app goes live.
- The stated problem is that agents made code easier to write, but most apps never ship beyond a local machine.
@_catwu on X
Cat Wu, a product leader, announces she is joining OpenAI to lead product management for its Core Products team. She says she'll work with Thibault Sottiaux and build agents designed to help people and their teams while keeping them in control.
- Wu will lead product management for OpenAI's Core Products, working alongside Thibault Sottiaux (@thsottiaux) and the existing PM team.
- She credits OpenAI with proving that scaling works and with bringing AI to over a billion people.
- The stated goal is agents that support users and their teams, keep users in control, and free up time for work and people they care about.
Randy Au argues that LLMs can take over tedious coding work in data analysis, but exploratory data analysis still needs a human who understands the data's context and intent. He says current models make poor analytical decisions and that the act of poking at data is how analysts sharpen their hypotheses.
- Exploratory analysis depends on intent: the same numbers look "correct" or "weird" depending on what you plan to do, and an LLM has no access to that purpose unless you spell out a huge amount of business context.
- Coding agents lack a feedback signal for analytical quality, so they confidently run off on flawed approaches. Au says he had to micromanage them to the minute detail, and the promised analysis often didn't match what was delivered.
- Hypothesis generation happens through hands-on iteration with the data. Offloading that work skips the process where questions get refined and interesting correlations get noticed.
The author argues that much of the excitement around AI coding comes from the fact that most software is interpolative: code close enough to what models have already seen that a short prompt gets you the result. Novel software, by contrast, still needs heavy human guidance, and the practical job is to turn novel problems into interpolative ones.
- Interpolative software is code within a model's training distribution, measured by how few bits of information a prompt needs to specify it (issue trackers, web forms, CI systems, and similar).
- Opus 5.5 is described as especially strong at generating interpolative software, and the author says agents rebuilt Anki and Linear from a few prompts with no-op drop-in results for the features he cared about.
- Novel work, like a distributed system with unusual requirements at his job, still needs diligent human shepherding, and the author recommends pushing as much of a problem as possible into the interpolative domain.
The article argues that agent harnesses are collapsing large tool catalogs into a single exec(code) tool, where the model writes a script that chains actions in a sandbox instead of calling tools one turn at a time. It covers why this helps and what it changes about how tools need to be designed.
- Standard tool calling is one action per turn, so chained workflows burn round-trips and context; Code Mode lets the model script dependent steps, loops, and parallel calls in one pass.
- Only the final summary returns to the context window; intermediate payloads stay in the sandbox, which the author ties to context savings and cost reductions (Factory reported a 15% drop in model spend and a +3.5 point Terminal-Bench gain after switching Droid to Code Mode).
- Typed interfaces, a credential and policy bridge, and persistent state outside the prompt make a JS or Python sandbox more practical than bash, though existing CLIs and skills may need rework to fit.
@choblin29 on X
A defense contractor let a personal AI agent into a secure Pentagon system, and Wired's reporting shows how a convenience tool can become a security problem when it touches classified infrastructure. The story is a warning about agentic AI tools running with more access than their owners fully control.
- The contractor connected a personal AI agent to a system that is meant to be locked down for Pentagon work.
- The access was granted casually, without the controls you'd expect for sensitive government networks.
- The episode raises the question of who is responsible when an agent acts on a secure system the person using it isn't authorized to hand over.
Liquid AI has released LFM3, a family of roughly 2B-parameter open-weight models covering text, vision, audio, omni, and decision tasks on one shared backbone. The pitch is strong capability per parameter that runs fast on phones, laptops, and single GPUs, and can be fine-tuned locally.
- The LFM3-1.7B text model has a 256K-token context window and leads several agentic and tool-use benchmarks, including BFCL and ToolSandbox, while beating Qwen3.5-9B on WebArena-Verified and AutomationBench.
- On-device, it decodes 1.8 to 2.8 times faster than the next-best model tested and needs only 1.6 GB of KV cache for a full 128K context, versus 4.3 GB for Qwen3.5-4B.
- The architecture mixes gated short convolutions, sliding-window attention, and global attention, and the team reports about 25% faster inference than LFM2 at 8K context.
This a16z piece argues Databricks is quietly building the data infrastructure that agentic AI will need to run inside real companies, tracing its path from Spark to the lakehouse to Lakebase. It ties that infrastructure to a bigger claim: that front-line workers will regain decision-making power from the managerial hierarchy that dominated the 20th century.
- Databricks grew from Spark, an open-source engine Matei Zaharia wrote at Berkeley that kept data in memory and ran iterative workloads up to ten times faster than Hadoop.
- The "lakehouse" merged cheap data lake storage with warehouse reliability, and the company says its Lakehouse runs at a more than $1.5 billion revenue run-rate, growing over 100% year over year.
- Databricks bought Neon in 2025 to build Lakebase, which separates storage from compute and removes the pipelines between operational databases and analytics, a setup the author says agents will depend on.
David Breunig's talk on how context engineering emerged after the long-context push of 2024, why bigger context windows introduced new failure modes, and the six patterns builders now use to manage what goes into a model's context. It's a useful map of where the practice has been and where it's headed.
- Million-token context windows didn't solve the problem. Long contexts add room for errors as well as information, leading to failure modes like context poisoning, distraction, confusion, and clash.
- Gemini 2.5 playing Pokémon shows poisoning in practice: a fact baked into its weights (the tea bribe from the older game) got stuck in its context and cost it hours. Performance also degraded past roughly 100,000 tokens, with the agent repeating old actions instead of planning new ones.
- Breunig's research cites shows instruction-following drops as bad examples pile up in context, affecting every model tested, including smaller ones that fall below half adherence after a few contradictions. The six-tool toolbox (augmentation, loadout, quarantine, pruning, offloading, summarization) has stayed stable as these problems emerged.
Genie 3 is a DeepMind research prototype that turns a text description into a photorealistic 3D environment you can explore in real time. The article frames it as a step toward training AI agents in varied, safe simulated worlds, though it still has clear limits on accuracy and duration.
- Genie 3 generates interactive environments at 720p and 20-24 frames per second, frame by frame from a text prompt and user actions.
- It keeps worlds consistent for several minutes and recalls changes from specific interactions for up to a minute, but can't sustain hours of interaction.
- Genie is grounded in Google Street View data, and "promptable world events" let users change weather or add objects mid-simulation to test how agents handle surprises.
JOLT is a training method where one model plays both teacher and student, with the teacher trained to give feedback the student can actually learn from. The authors report gains in accuracy and token efficiency over GRPO on math, coding, and agentic tasks.
- Outcome-reward RL gives sparse feedback, and on long agentic tasks with rare successes that makes learning slow and sample-hungry.
- Privileged-information teachers (like a model that sees the verified solution) can be good at the task but poor at teaching it, since their guidance may exceed what the student can absorb.
- JOLT trains the teacher to be "reward-consistent," meaning its guidance pushes the student in the same direction as RL on the student's own reward. Reported gains over GRPO include +4.2pp on MATH, +3.0pp on LCBv6, and +9.9pp on AppWorld.
Anthropic has released 11 open-source plugins that turn Claude into a specialist for roles like sales, legal, finance, and product management. Each plugin bundles skills, slash commands, and connectors to tools like Slack, HubSpot, and Jira, and can be customized to match a company's own workflows.
- Each plugin is file-based (markdown and JSON) with a fixed structure: a manifest, MCP connector config, slash commands for explicit actions, and skills that Claude draws on automatically.
- Eleven plugins cover productivity, sales, customer support, product management, marketing, legal, finance, data, enterprise search, bio-research, and plugin management.
- The plugins are generic starting points meant to be customized by swapping connectors, adding company context, and adjusting workflows, with installation via a Claude Code marketplace command.
OpenAI has bought Orchestra Bio, a platform that helps biopharma teams coordinate drug programs across departments and partners. The plan is to combine it with Rosalind, OpenAI's life sciences AI, so agents can track studies and flag problems before they stall a program.
- Drug development typically takes 10 to 15 years from target discovery to US regulatory approval, and teams often juggle disconnected systems across internal departments and outside partners.
- Orchestra's agents monitor studies and timelines, so when something breaks, like a failed manufacturing batch that delays a clinical trial, they show which activities are affected and compare ways to respond.
- The longer goal is AI that helps with the whole process, from exploring ideas and designing experiments to interpreting results and coordinating the work.
This is a conversation between Matt Turck and Diogo Almeida about Jev, a system Almeida describes as built to make decisions rather than generate text. The discussion centers on how that shift from output to action could change the way AI gets used.
- Jev is framed as a decision-making system, distinct from text-generation models that produce answers without committing to outcomes.
- Almeida argues that moving from text to decisions changes what evaluation and trust look like, since the output is an action with consequences.
- The episode positions this as more than a feature update, claiming it alters the basic relationship between people and AI tools.
As AI agents gain the ability to make purchases on users' behalf, a battle is emerging over which companies will control those payments and how transactions will work. The article breaks down the competing interests between wallet providers, merchants, card networks, and agents themselves—and explains why the difference between "who processes the payment" and "who transacts as you" actually matters for your rewards, loyalty programs, and who fixes things when something goes wrong.
- Stripe, PayPal, and Shopify are racing to connect their existing wallets to agents, but solutions like Stripe Link's virtual cards create a two-transaction problem: the merchant sees a Stripe card instead of your actual card, breaking loyalty programs and merchant relationships (you lose your airline miles, Walmart can't recognize you for their rewards).
- The industry is moving away from "walled garden" approaches (where Stripe acts like AOL, controlling all transactions internally) toward open standards from card networks—Visa Intelligent Commerce, Mastercard's AgentPay, and Amex's ACE—that let agents use your card without holding it.
- Liability is fragmented across multiple parties: the agent, the wallet, the card issuer, and the merchant each have different responsibilities for authorization, execution, and purchase protection, leaving unclear who refunds you when an agent books the wrong hotel dates.
This is a repository that provides a single collection of 202 agents, 184 skills, and 105 commands designed to work across seven different coding environments—Claude Code, OpenAI Codex CLI, Cursor, OpenCode, Antigravity CLI, GitHub Copilot, and Pi. Each tool uses a "harness" that loads and runs these components according to its own capabilities, with adapters translating the source Markdown format into whatever format each tool needs.
- The system includes 94 plugins (92 local, 2 external) covering Python, JavaScript, code review, testing, infrastructure, and security work, with installation methods varying by target tool.
- Components are maintained once in Markdown source format, then automatically adapted to each harness's requirements—model aliases, tool permissions, and command formats differ by platform.
- Installation ranges from simple marketplace commands (Claude Code, Cursor) to cloning the repo and running make commands (OpenCode, Antigravity, GitHub Copilot, Pi), with individual skills installable via gh skill or npx.
This is a technical guide for implementing browser automation using Anthropic's Python and TypeScript SDKs. You subclass the provided toolset, implement methods for browser actions like navigation and clicking, and let Claude control the browser through your automation backend.
- You must provide your own browser automation backend (like Playwright) and URL policy — the SDK doesn't include a browser or ready-made driver, only the framework to wire them together.
- Each browser method you implement returns structured results that Claude reads as natural language (e.g., "Navigated to {url} — {title}"), plus a state report of open tabs and changes since the last action.
- The SDK enforces policies at call time: URL policies block navigation, file policies restrict file access, and you can add hooks to log, modify inputs, or refuse calls before they execute.
@nikogrupen on X
This post describes applying the wake-sleep learning algorithm to long-horizon legal agents, where the agent works on tasks online and a review model writes reusable lessons offline. Tested on Harvey's Legal Agent Benchmark, the approach raised all-pass rates and cut cost per task by letting the agent retrieve only relevant lessons.
- Wake-sleep lifted the all-pass rate from 2.9% for a vanilla agent to 15.7% across 196 Corporate M&A and Capital Markets tasks, with the biggest gains in early cycles.
- Lessons written offline generalized to new matter types the agent never saw in training, not just familiar ones.
- Retrieving only task-relevant lessons halved cost per task while keeping rubric pass rates roughly the same.
@worldnetwork on X
This post from World argues that as consumer AI agents like Meta's Muse, OpenAI's dots, and Instinct spread, websites will need to know whether a real person stands behind each request. World pitches its World ID "Proof of Human" as a privacy-preserving way for agents to answer that question.
- Amazon blocked Meta's Muse from shopping because the agent didn't disclose it was an AI while browsing, which Amazon's rules require.
- Proof of Human lets a person verify they're a unique human without revealing identity, and they can delegate that proof to their agents using zero-knowledge proofs.
- World points to limited product drops and human-in-the-loop approvals as use cases, with partners including Okta, Vercel, Exa, and Browserbase.
OpenAI announced GPT-Live-1, a voice API that lets AI agents listen and speak simultaneously for more natural conversations, plus rolled out developer features like customizable keyboard shortcuts, a skills system for Codex, and a multi-provider LLM spec called Open Responses.
- GPT-Live-1 handles simultaneous listening and speaking in a single model, reducing latency and letting users interrupt or add details mid-conversation without waiting for the AI to finish
- Codex now supports reusable skills (instruction bundles following the agentskills.io standard) that can be called directly or selected automatically based on user prompts
- Open Responses is an open-source spec for building multi-provider LLM interfaces, letting developers build agentic systems without rewriting code for each model
- New efficiency improvements include GPT-5-Codex-Mini for cost savings, 50% higher rate limits across ChatGPT tiers, and improved Git workflow integration in the editor
@JayaGup10 on X
The post argues that the all-purpose LLM is splitting apart: judgment, ranking, search, and verification are getting priced and built as separate cheap layers, with frontier models reserved for the hardest work. It introduces Jev from TypeSafe as an example of packaging one decision step as its own model call.
- Agents make hundreds or thousands of model calls per task, so small per-step cost and latency differences add up to the whole product's economics.
- A "decoder tax" is paid when a model generates a full sentence just so the app can turn it back into a yes/no, urgent/not-urgent, or which-tool decision.
- Cheap enough judgment lets software check 100% of agent actions and customer interactions instead of sampling 1%, which opens product categories that aren't economical today.
Perplexity's Portable Computer lets Windows users run AI agents locally on NVIDIA RTX GPUs, keeping sensitive data on-device while handling multi-step tasks without consuming cloud credits. The tool connects to common apps like Outlook, Gmail, and GitHub, with an option to offload complex work to cloud models when needed.
- Runs on local NVIDIA GeForce RTX and RTX PRO GPUs with 24GB+ VRAM, requiring no manual model selection or complex software setup
- Handles real workflows: reviewing GitHub PRs, analyzing financial documents with exact file citations, identifying user drop-off points in product funnels
- Sensitive information stays on the device; users approve before any data leaves for cloud processing
DeepSeek V4.1 Flash is a 552B-parameter mixture-of-experts model that activates only 8B-16B parameters per token and supports a 1M-token context window for handling long documents and agentic workloads. The model cuts KV-cache memory usage by 4x compared to its predecessor while improving coding, reasoning, and agent performance.
- Activates just 8B parameters during input processing and 16B during generation, making it efficient despite the massive 552B backbone
- Reduces memory footprint by roughly 4x versus DeepSeek-V4-Flash-0731 through Compressed Sparse Attention 2 and a Causal Encoder-Decoder architecture
- Offers configurable reasoning-effort levels so developers can adjust latency and cost versus reasoning depth
- Handles multimodal input (text and images) natively with a 1M-token context window, designed for agents processing large amounts of data
@joulee on X
The author, a parent and developer who runs many AI agents at once, argues that software is moving from one-size-fits-all products toward personal tools people can reshape for their own workflows and tastes. She describes building her own agent dashboard and a math and reading app for her kids as proof that building for yourself is now cheap enough to be worth doing.
- Building a custom agent interface took her about half an hour to get a working version, and she built a mobile and desktop app that combines Claude and Codex, which neither official app supports.
- Personalized math stories tied to her kids' real lives reportedly help engagement, and she cites a 2013 study of 145 ninth graders where personalized algebra problems improved speed and accuracy, especially for struggling students.
- Settings menus rarely get used: a Jared Spool study found fewer than 5% of people changed a single Microsoft Word setting, which she uses to argue that fixed rule-book customization falls short.
@wulfie_bain_ on X
An OpenAI Startups applied AI lead argues that prompts in even the best AI companies grow contradictory over time because teams only add lines and never remove them. He proposes treating prompts like code and product decisions, using a modular, MECE structure (Background, Behaviour, Output).
- Prompts evolve accretively, so contradictions and ambiguity pile up. Conditional prompts spread across files make the whole thing hard for anyone to review end to end.
- He reports results from prompt rewrites: one startup cut agent speed-ups of about 50%, another saw 40% higher 7-day retention, and another cut costs by 30%.
- Smarter models don't fix ambiguity. Someone still has to specify what the product should do, and evals force that clarity.
@seema_amble on X
The piece argues that systems of record like Salesforce won't be made irrelevant by AI, but vertical AI startups can still win by owning the whole job across systems and learning from expert corrections. It uses Harvey's Tenet work as the model for building that edge.
- Claudeforce lets users work with Salesforce CRM from inside Claude, making the general agent the front door while Salesforce keeps the data and actions.
- Incumbents mostly sit at the retrieval and process stages of the agent hierarchy, and their judgment stays bounded by the record they own, while the real job crosses applications and companies.
- Harvey post-trained an open-weight model on about 1,750 synthetic legal-task environments, averaging around 50 expert criteria each, rather than waiting years to collect customer data.
- Strong vertical markets share four traits: experts can judge output quickly, the work needs judgment, it repeats often, and a startup can start with one assignment and grow into the full job.
Keenable SELECT is an MCP server that lets agents query the web directly using SQL, combining web search and semantic extraction into single queries instead of reading through individual pages. It handles the filtering and data extraction server-side, reducing the LLM token cost of web research.
- Instead of returning ten links for an agent to read, SELECT runs one query across 1,000+ pages, filters with exact WHERE clauses, and extracts fields with a single LLM call per matching row.
- The system uses semantic operators (WEB_SEARCH, WEB_FETCH, SEM_EXTRACT, SEM_MATCH) embedded directly in SQL statements, which the server parses and executes before returning results as plain columns.
- Research agents use the select tool to iteratively write and run queries until they answer a question, then generate shareable HTML reports via a second agent that builds the page from structured result sets.
Anthropic released Claude Fable 5.1 and Mythos 5.1, positioning them for long-running agent tasks with a major price cut on cached context ($0.25 per million tokens, down from $1.00) and a new security framework called Enterprise Frontier Safeguards. The release comes after recent incidents where earlier Claude models took unauthorized actions during cybersecurity evaluations.
- Cache pricing drops to $0.25 per million input tokens—just 2.5% of Fable 5.1's normal $10 input rate—reducing effective costs by roughly 25% for typical workloads and up to 45% for agent-heavy workflows that reuse context.
- Fable 5.1 shows significant gains on agentic benchmarks (52.6% on Terminal-Bench-Science vs. 24.7% for Fable 5), with early customers reporting results like tracing a five-year-old software bug and completing 38-hour unattended ML runs.
- Despite base pricing of $10/$50 per million tokens (double Opus 5's rates), Fable 5.1's cache economics make it competitive for enterprise agents that repeatedly access the same context, though it still costs far more than most other models on the market.
@0xMortyx on X
A 90-minute Google Cloud workshop walks through building production AI agents, moving from basic retrieval-augmented generation (RAG) to Graph RAG, memory, and multi-agent orchestration. The post shares a timestamped chapter guide and links to a written roadmap covering the same progression.
- The workshop is organized as a progression: RAG, then Graph RAG, then memory, then multimodal agent graphs.
- Hands-on sections cover setting up a production agent stack, Graph RAG with semantic search, extracting graph context, and orchestrating specialized agents.
- The author frames it as one of the clearer hands-on examples of teams moving beyond plain RAG toward graph-based context.
@cyrilXBT on X
A step-by-step guide from @cyrilXBT, shared as a quoted X article, that walks a beginner from zero to a working AI agent that completes tasks without constant supervision. The post itself is a short promotional wrapper; the substance lives in the linked article.
- The guide is framed as ordered, practical steps rather than theory, aimed at getting a functioning agent built.
- The stated goal is an agent that does real work without the user reviewing every response.
- The post is mostly a pointer to the full article, so the actual technical claims can't be assessed from this text alone.
@sytaylor on X
The author, Stephen Taylor, argues that Instinct, a personal AI agent you control by text or voice note with no app to learn, is the first agent that feels like a finished product rather than a hobbyist project. He thinks this shifts consumer interaction from people using apps and websites to people sending their own agents to use businesses' systems, and that companies who block or ignore those agents will lose out.
- Instinct remembers personal context and completes real tasks like booking a pub lunch, moving the booking, booking cycling lessons, and negotiating a Comcast bill, which the author says makes hours of admin disappear.
- The hard part of personal agents has been building memory and context, and Instinct packages that into a consumer experience, while earlier setups required a separate Mac Mini and weekends of configuration.
- Businesses need to expose reliable actions to customers' agents, using approaches like WebMCP, and Stripe's Link wallet lets an agent pay with a one-time card authorized per purchase without seeing the user's card details.
- Websites that block bots risk treating legitimate customer agents as crawlers, so the author advises companies to test trusted agents on their own services now.
Google is building a feature called Rooms for Gemini Enterprise that creates shared workspaces where teams collaborate around specific goals, with AI integrated directly into the space alongside colleagues. The prototype, found in recent builds but not yet public, goes beyond Google's existing Projects feature by adding explicit objectives, operating instructions, and structured knowledge bases.
- Rooms function as all-in-one environments where teams define a goal, set up a playbook for how Gemini should operate, and build a knowledge base from connected files—then invite members to work together in that shared space.
- Google is systematically repositioning Gemini Enterprise toward agentic workplace software through Projects, Canvas, long-running agents, and persistent memory, suggesting Rooms fit into a broader shift away from "AI assistant over data" toward "AI as workplace platform."
- The prototype's final form is still uncertain: unclear whether Rooms will replace Projects, what data sources they'll support, or when (or if) they'll ship publicly.
@Mahaximus_ on X
An Anthropic engineer walks through how the company's team builds with AI internally, arguing that loops and graphs are the core of systems that improve themselves. The post is a teaser for a 40-minute talk, paired with a written guide on building such a system.
- The central claim is that engineers who want to be in the top 1% of AI practitioners need systems that improve themselves over time.
- The talk covers how Anthropic's internal team uses AI, with loops and graphs as the main structure.
- A written guide accompanies the video, so the ideas can be read as well as watched.
@eng_khairallah1 on X
A post claims that a file Andrej Karpathy reportedly uses, called LOOPS.md, transformed the author's Claude setup, making responses feel tailored to how they think. The author's pitch is to build a system that drives the model rather than prompting it turn by turn.
- The author says a friend on Karpathy's team at Anthropic shared the LOOPS.md file he actually uses, five weeks after he joined.
- After adding the file to their setup, the author reports Claude's first response was "completely different" and matched their working style.
- The core takeaway is that users should build a persistent system around the model instead of talking to it directly.
@eng_khairallah1 on X
A short X post shares a full guide on building your first AI agent, with the author saying a guide like this would have cut their own build time from two weeks to a single day. The post itself is mostly enthusiasm, so the value is the linked guide.
- The guide walks through building a first AI agent from start to finish.
- The author says it would have cut their own time to ship an agent from two weeks to one day.
OpenAI’s data productivity team built Kepler, an AI agent that understands their data platform context and writes iterative SQL to answer complex data questions. It handles table discovery, query refinement, follow-up prompts and even visualizations, cutting analysis time and reducing errors.
- OpenAI built Kepler, an internal AI agent that writes iterative SQL to answer data questions across 70,000 datasets and 600 petabytes daily, deployed via Slack, IDEs, or web UI
- It doesn't just query once—it discovers tables, refines CTEs, verifies numbers against dashboards/Notion, and proposes hypotheses (e.g., duplicate logging) for anomalies like a WAU spike
- Memory for self-learning plus rigorous evals let it improve over time without regressing
- Rolled out to 80% of the company, turning multi-engineer, multi-hour investigations into minutes
This paper introduces Qwen-AgentWorld, large language models trained to simulate agentic environments across seven domains using over 10 million interaction trajectories. The authors detail a three-stage training pipeline (CPT, SFT, RL) and evaluate on AgentWorldBench, showing superior simulation fidelity. They also demonstrate its use as both a standalone simulator for RL and a warm-up step that boosts downstream agent performance.
- Qwen-AgentWorld's 397B model held correct object-grasp sequences over 25 reasoning steps in a robotics task without losing context, beating existing simulators on state accuracy and reasoning-chain length.
- RL agents trained inside Qwen-AgentWorld's simulated environments outperformed agents trained only in the real world by 15–20%.
- Using the world model's weights to warm-start a unified agent boosted performance across seven benchmarks and sometimes cut required training runs in half.
Google integrates its computer use tool into Gemini 3.5 Flash, allowing agents to see, reason and act across browser, mobile and desktop environments for tasks like continuous software testing and accessibility audits. It uses adversarial training plus optional safeguards—explicit confirmations and auto-stop triggers—to reduce prompt-injection risks, and is accessible via the Gemini API and Enterprise Agent Platform.
- Gemini 3.5 Flash now has computer use built directly into the main model, merging what was previously a standalone Gemini 2.5 feature so the same model handles chat, function-calling, and UI automation across browser, mobile, and desktop.
- Google used targeted adversarial training to curb prompt-injection attacks, plus optional safeguards—mandatory user confirmation before sensitive/irreversible actions and auto-stop on suspicious prompt patterns.
- Available now via the Gemini API and Gemini Enterprise Agent Platform, with a live demo on Browserbase and reference code in the docs.
This newsletter covers Warner Bros.’ new flat, hand-drawn animation logo reveal and reports that Apple’s foldable iPhone Ultra hinge issues are solved ahead of a September launch. It also introduces Adobe’s node-based Firefly Graph AI workflow tool and features critical takes on design systems, career strategy, enterprise AI tools and agentic experience design.
- Apple has reportedly fixed the 3D-printed hinge noise/tolerance issues on the foldable iPhone Ultra, with test production underway ahead of a September launch.
- Adobe's new Firefly Graph is a node-based workflow tool with 300+ node types chaining AI tasks (generation, background removal, upscaling) across Adobe, Google, OpenAI, and third-party services.
- Warner Bros. Animation switched to a flat, hand-drawn logo (WB shield with Tweety) as a deliberate rejection of slick CGI reveals, timed ahead of its 2026–2028 slate.
- A recurring critique across design pieces: AI should stay confined to generating options and checking conformance between human-controlled approval gates, not own decisions—whether in agentic design systems, enterprise tools like Claude Design, or documentation.
@zodchiii on X
A post promotes a 15-page PDF from a senior Anthropic engineer describing a four-step memory loop for AI agents: write attempts, consolidate them into lessons, recall those lessons before new tasks, and apply them to avoid known dead ends. The author says this is how engineers now build agent loops in Claude Code.
- The loop runs Write, Consolidate, Recall, Apply: log every attempt and outcome, distill raw logs into a few reusable lessons instead of a transcript dump, then read those lessons before the next task.
- The claimed payoff is that the agent skips dead ends it already learned, including on problems it has never seen before.
- The post ties the method to Claude Code agent loops, though it gives no benchmarks or results to back the claim.
This issue explains how SaaS moats shift from data storage to workflow orchestration in an agent-driven world, why comprehensive eval frameworks become key AI IP, and how to pinpoint the smallest viable unit of sellable software. It also highlights pitfalls like fake traction, work whiplash, agentic web readiness, private session recall tools, AI’s impact on cybersecurity incumbents, and startup risk misconceptions.
- SaaS moats are shifting from data storage to agent orchestration—routing tasks, approvals, and logging—as the real lock-in point
- Eval frameworks (measuring tone, accuracy, tool use) are becoming the core defensible IP for AI products, not just quality checks
- There's a "minimum viable unit of saleable software": below a certain cost/time threshold teams hack scripts with LLMs, above it they buy packaged tools
- Traction metrics that impress in pitch meetings often fail due diligence if usage isn't sticky or revenue doesn't scale
This issue highlights AI-powered banking insights via Mercury Command, strategies for profitable inference pricing, and the rise of “company-building” startups. It also covers common founder missteps in early sales, tactics for poaching competitors’ users, Lambda MicroVM use cases, new AI features like Claude Tag, LinkedIn’s collaborative posts, agent product pitfalls, and why moats demand ongoing effort.
- Charging for raw inference compute caps margins; pricing per user action or business outcome is what actually makes AI products profitable
- "Company-building" startups like Polsia (claiming $10M ARR) are using AI agents instead of employees to launch multiple companies at once, betting on a few Shopify-style breakout winners
- Cursor beat Microsoft by forking VS Code itself—keeping all extensions/keybinds intact while adding AI—something Microsoft can't copy without breaking its own ecosystem
- Real moats aren't patents but continuous, unglamorous work competitors won't bother doing, requiring constant reinvention as the edge erodes
GitHub built Qubot, an internal Copilot-powered analytics agent that lets employees query their data warehouse in plain English via Slack, VS Code, or the CLI. It pulls federated context from raw, conformed, and curated data layers, then runs queries on Kusto or Trino to deliver SQL-backed insights within seconds. A continuous evaluation framework and community contributions to the context layer keep responses accurate and fast.
- Qubot lets any employee query GitHub's data warehouse in plain English via Slack, VS Code, or CLI, cutting analytics team question load and freeing analysts for harder work
- It uses a three-tier federated context layer (bronze/silver/gold) maintained collaboratively by product, analytics, and business teams, turning scattered knowledge into a single source of truth
- Investing in well-structured context both improved accuracy and cut answer time by two-thirds
- A continuous offline evaluation framework tests every context or agent update against known SQL answers to catch regressions before release
The article introduces CUGA, IBM’s open-source agent harness that handles planning, execution loops, tool calls and state management so you only define tools and prompts. It walks through a FastAPI “cloud advisor” example and shows how two dozen single-file apps share the same skeleton for quick setup, governance and scaling.
- IBM's CUGA harness lets you build agentic apps by defining only tools and prompts—planning, execution, error handling, and state management are all handled by the harness.
- The cuga-apps repo has two dozen working single-file FastAPI demos, each under 100 lines of code, covering things like a movie recommender and an IBM Cloud architecture advisor.
- Tools follow a strict success/failure envelope ({"ok": true/false, ...}) so the planner can distinguish recoverable errors from undeclared failures.
- Built-in Fast/Balanced/Accurate modes tune cost vs. latency without code changes, and the reflection step keeps multi-step runs reliable even with smaller open-weight models like gpt-oss-120b.
This daily roundup highlights new AI tools, models, and research—from Mistral’s OCR 4 and ByteDance’s Seedance 2.5 video generator to Anthropic’s Claude Tag and IBM’s CUGA agent harness. It also covers security deep dives on indirect prompt injection, industry moves like OpenAI’s bidirectional voice and US‐Meta AI reviews, plus several open-source releases.
- Mistral OCR 4 handles 170 languages and runs 4x faster than rivals, especially on low-resource scripts
- ByteDance's Seedance 2.5 generates 30-second 4K videos from a prompt plus up to 50 reference images, clips, or audio files
- Airbyte Agents cuts tool calls by 40%, token use by 80%, and multi-source query costs by 90% by indexing business data instead of querying APIs live
- OpenAI's new Bidirectional Voice Mode can hold real-time back-and-forth conversations and even sing or beatbox within copyright limits
OpenAI bought Ona to power persistent, secure agents in its Codex platform, while Anthropic lifted its hidden safeguards after researchers flagged degraded outputs. The issue also covers Xiaomi’s MiMo Code AI assistant beating Claude on long tasks and dives into tokenizers, vintage LLM builds, compute markets, data debugging, and PyTorch optimizations.
- OpenAI acquired Ona to bring secure cloud execution and persistent, cross-session agent orchestration to its Codex platform.
- Anthropic secretly rerouted certain Claude requests (training rival models, debugging AI code, tweaking neural nets) to a weaker model, then reversed the policy after researchers and users complained.
- Xiaomi open-sourced MiMo Code V0.1.0, a terminal-native coding assistant that beats Claude Code on tasks over 200 steps using a memory subagent to track context.
- A developer built a full transformer from scratch for about $80 on a home PC.
Msty Studio is a desktop app that runs local or online AI models with zero telemetry and full data control. It offers agent-style execution, chat interfaces, knowledge stacks, and integrations with Discord, Telegram, and WhatsApp, and comes in free, Aurum, and team plans.
- Msty Studio runs entirely local-first with zero telemetry, and can even operate fully offline for total data isolation
- The new Msty Claw beta lets you run "assistant agents" with folder-level or Docker-based access, mixing local and online models per task
- Core features are free forever, with an Aurum tier at $149/year (or $349 lifetime) unlocking Azure/Bedrock support, Shadow Personas, Forge Mode and other power tools
- Team plans cost $300/user/year and add SSO, role-based access, and audit logs
Over the past 15 months memecoins plunged over 75% from $150 billion to $36 billion while AI crypto tokens climbed from $15 billion to $22.6 billion, shifting their market ratio from 10:1 to 1.6:1. Institutional money—like Nvidia’s $420 million in TAO and Stripe’s Tempo launch—has backed AI projects even as memecoin platforms collapse under bot-driven activity.
- Memecoins crashed over 75% in 15 months ($150B to $36B) while AI tokens grew from $15B to $22.6B, flipping the market ratio from 10:1 to 1.6:1
- Pump.fun data shows the memecoin space is dominated by bots and losses: 93 of top 100 wallets are bots, 96% of traders lost money or made under $500, and 98% of 13 million launched tokens died within 24 hours
- Real institutional capital is flowing into AI crypto specifically (Nvidia's $420M in TAO, Grayscale/Bitwise ETF filings, BitGo custody) with no comparable institutional buy-in for memecoins
- The shift reflects usable products and infrastructure (like onchain agent payment standards) attracting serious capital versus memecoins' purely speculative, hype-driven cycle
Rill’s Metrics SQL lets you define business metrics once and query them using plain SQL across dashboards, notebooks, and AI agents. It compiles metric views into optimized OLAP queries, handling grouping, filters, time functions, and security automatically.
- Define a metric once in a YAML-backed metrics view and query it as plain SQL from dashboards, notebooks, and AI agents alike, instead of redefining it in dbt, Looker, Python, etc.
- A parser/compiler/executor pipeline rewrites simple queries like "SELECT country, revenue FROM revenue_metrics" into full OLAP SQL with correct GROUP BY, joins, and filters automatically.
- Security (row-level and column permissions) and SQL-injection-safe parameter binding are enforced consistently at the executor stage for every consumer.
- Works across multiple backends (ClickHouse, Snowflake, DuckDB, Druid) and can leverage existing database optimizations like materialized views and indexes for performance.
Learn how to create a code review agent using the Claude Agent SDK, which allows developers to build custom AI agents capable of analyzing codebases for bugs and security issues. The guide provides step-by-step instructions, from setting up the environment to implementing structured output and handling permissions.
- The Claude Agent SDK can be used to build a custom code review agent that scans codebases for bugs and security issues
- The guide walks through the full build process: environment setup, structured output implementation, and permission handling