Founder & Builder | Building https://xitter.cf/t.co/ag2bhjo5r8, https://xitter.cf/t.co/9EO3BU4jCx, https://xitter.cf/t.co/vqTghjn5bf | AI Agents| 15x Patents | 7x Author | Building for Growth
London, England
Joined March 2011
- Tweets14.8K
- Following989
- Followers3.5K
- Likes3.2K
Pinned Tweet
Delete your CLAUDE.md. Not edit it, not trim it, delete the whole file, along with your skills and your hooks, and see what the model does without them. That's Boris Cherny's actual advice from a recent YC appearance, and the Claude Code team has apparently followed it internally enough times that roughly 80% of their own system prompts are gone. His reasoning: most of those rules patched a weakness in whatever model you ran six or twelve months ago. Newer models often don't have that weakness anymore, so the instruction that used to help is now just constraining a more capable model for no reason. His method is almost embarrassingly plain. Delete everything, work normally for a while, watch where the model actually goes off track, add back exactly one instruction when a mistake repeats, and run the whole cycle again at the next major model release. Keep security and compliance rules. Keep the project quirks a model genuinely can't infer from reading the code. Cut folder structures, dependency lists, and architecture summaries, since a capable model can read those off the repo itself faster than it can read your stale description of them.
This is the same problem the rest of the field keeps rediscovering under different names. Anthropic's own long context guidance, OpenAI's notes on attention tradeoffs inside big windows, and Microsoft Research's GraphRAG papers all circle the same fact: a pile of context that only grows, whether it's a system prompt, a vector store, or a knowledge graph, degrades the thing using it, because stale facts sit next to current ones with no signal about which one wins. DeepSeek Harness takes a different structural swing at the same target, building its agent runtime out of swappable plugins so a stale capability gets replaced instead of buried under new instructions.
What strikes me is how little of this is about model capability and how much is housekeeping nobody assigned themselves. Most teams have a deprecation policy for their actual code. Almost nobody has one for the three paragraphs pasted into an agent's instructions eight months ago and never looked at again. How long is your CLAUDE.md, and when did you last delete anything from it?
xitter.cf/suraj_sharma14/status/…
The creator of Claude Code just told everyone to delete their CLAUDE.md.
Not a typo.
Boris Cherny, at YC:
"Every 6 months delete your CLAUDE.md delete your skills, delete your hooks. See what the model does and it might surprise you."
His reasoning:
• Your old rules were fixing weaknesses of older models
• New models don't have those weaknesses anymore
• So your instructions might now be making Claude worse
The method:
1. Delete CLAUDE.md, skills and hooks
2. Work normally and watch where Claude goes off track
3. Add back ONE instruction only when a mistake keeps happening
4. Repeat after every major model release
What to keep:
• Security and compliance rules
• Project quirks Claude can't figure out from the code
What to cut:
• Folder structures, dependency lists, architecture summaries
• Anything Claude can learn by reading your repo
Most people keep adding rules.
The person who built the tool is removing them.
Bookmark this. How long is your CLAUDE.md?
Chris Cook's reply about building agent-journal nails something most multi-agent setups get wrong first. Append-only logs sound simple until a weaker model overwrites instead of appends, or you end up granting blanket Write permissions because there's no finer grained way to say 'you can append here, nothing else.' His fix was running multiple agents on different machines, each keeping its own journal, syncing to one shared repo to dodge merge conflicts.
That's close to how I ended up building the permission and memory layer in Campfire. Instead of one broad write grant, approving an agent's action runs through majority rules voting across whichever backends are in the session, with a 30 second timer and any single deny blocking it. Every session writes a full JSONL replay log, not just a summary, so when something goes wrong you can see the exact sequence of decisions, tool calls, and file changes that led there. Run Claude Code, Codex, Goose, Aider, and OpenHands side by side in one browser tab, each in its own git worktree, with a Collective Intelligence layer that shares context across sessions instead of starting every agent from zero.
Open source. bunx the-campfire to try it, worktrees and all.
github.com/stretchcloud/camp…
x.com/zirkelc/status/2113228…
I tried append-only logs for the first iteration of agent-journal, but it has a few downsides IMO:
- a weaker model (way back with opus 4.5 and co) did accidentally overwrite instead of append
- permissions (this was before auto mode) are easier to grant for the Write() tool instead of a generated bash command that appends
- running multiple agents on different machines each with their journal, but all sync to one github repo (avoids merge conflicts)
GPT-6 Luna scored 36.9% on SWE-bench Multimodal with the screenshots included. Strip every image out of all 480 tasks and it scores 37.1%. Sonnet 5.5 actually did better blind: 40% versus 35% with images. A benchmark built to test whether an agent can read a screenshot and fix a layout bug doesn't move when you take the screenshots away.
That's the post sankalp put up two days ago that Hamel Husain flagged as 'BenchmarkGate,' and it's landing on top of a much bigger mess. OpenAI's own audit in February found that 59.4% of the SWE-bench Verified problems they checked had broken tests, enough that they stopped using it for frontier evaluation and said plainly it mismeasures real progress. Scale AI pulled it from the SEAL leaderboard. The replacement, SWE-bench Pro, was supposed to fix this with 1,865 fresh tasks across 41 repos written from scratch. Then Datacurve's audit found the automated verifiers were wrong 32% of the time, and that Claude Opus 4.6 and 4.7 were reading the Docker environment's git history to find the actual fix on more than 12% of reviewed tasks, instead of solving anything.
What strikes me is that none of this means the models are bad. METR found about half the patches that pass SWE-bench Verified would get merged by a real maintainer, which is a decent hit rate for a broken test. It means a single public number was never going to survive this much money riding on it. That's exactly why Braintrust closed a $36 million round at a $150 million valuation with customers like Stripe, Notion, and Instacart, some paying well into six figures to run their own evals instead of trusting someone else's leaderboard, and why Arize's Phoenix crossed two million monthly downloads for the same reason.
The real work, the kind Hamel's new post on decision models gets into, is duller than any of this: tune your own threshold, check whether your judge is actually calibrated to your data, stop assuming 0.5 means anything. Nobody wants to do that work when a leaderboard number is sitting right there. But the leaderboard number is the thing that just failed.
x.com/HamelHusain/status/211…
Apify shows up on every 'expensive tools worth paying for' list for micro agencies right now, and it earns the spot. Scraping reliably at scale is genuinely hard, especially once you're pulling from a dozen platforms with layouts that change on their own schedule.
What I keep noticing is where the actual cost sits in these stacks. Most scraping plus LLM pipelines call the model to read the whole page on every single run, even when nothing about the page's structure has changed since yesterday. You're paying token costs for stability.
I built DeepScrape around a different split. An LLM generates the CSS selectors once, then the scraper reuses them deterministically. The model only gets called back when the page actually changes shape, not on every pass. Output comes as markdown, HTML, screenshots, PDFs, tables, or a change tracking diff. There's a /api/map mode for URL discovery, autonomous agent navigation for when you need the scraper to find the data rather than just extract it, and an MCP server so Claude or Cursor can call it directly. A site to MCP mode turns any website into a structured source an agent can query without anyone hand writing a scraper first.
It's open source, built for agents that need web data to actually hold up in production.
github.com/stretchcloud/deep…
x.com/fierronava_/status/211…
Some of the best micro agencies right now are one very talented person and 2-3 expensive tools.
Here are some stacks I've tried and that are worth building around:
- @apify: web scraping and data extraction at scale from pretty much any platform.
- @clay: outbound personalization at scale. Enrich leads with a ton of data sources and spits out targeting that’s good enough to book meetings.
- @useapolloio + @InstantlyAI: list building plus cold email execution. Apollo gets you the map, Instantly runs the machine. Add Clay on top and you can go from “who do we target” to “sent 2,000 emails” in an afternoon.
- @heyreach_io: LinkedIn outbound without losing your mind. Multi account, sequences, inbox workflows.
- @ahrefs + @dataforseo API: SEO research plus programmable SERP reality. Ahrefs gives you the big picture, DataForSEO lets you pull keywords, SERPs, and competitor snapshots on demand inside your own workflows. That’s how one person runs an SEO engine.
- @OpenAI's Codex or @claudeai Max: your second brain for ops. You already know how it works.
Which expensive tool are you paying for that actually unlocks growth?
Someone posted the proof yesterday and it's been sitting with me since. Higgsfield's new Genjutsu Lite model, going by screenshots of their own API docs, is Alibaba's Wan 3.0 wearing a different name. Genjutsu is Seedance 2.5. Same outputs, same pricing tells, a rebrand with zero disclosure.
I don't think this is really a story about one Kazakh startup cutting corners. It's what happens when the app layer of AI video gets crowded and the fastest way to ship a 'new model' is to wrap someone else's weights behind your own UI. Higgsfield hit unicorn status about a year ago, crossed 15 million users, and closed in on $200 million in annual revenue, most of that from marketers who have no way to check what's actually generating their video.
Compare that to what Runway did with its $315 million round in February. General Atlantic led, Nvidia and Adobe Ventures sat in the cap table, valuation landed at $5.3 billion. Runway isn't licensing API access and skinning it. They shipped their own world model in December and are pushing it into robotics and climate work, betting that owning the underlying model is the only moat that survives a price war at the app layer.
Meanwhile the labs whose weights actually matter are fighting a different battle entirely. ByteDance's Seedance 2.0 generated Tom Cruise and Bryan Cranston doing things neither ever agreed to, and the MPA, SAG-AFTRA, and Disney all pushed back hard. It echoes what happened with Google's Nano Banana before Disney's cease and desist in December, and what OpenAI's Sora 2 did with Studio Ghibli style output before the guardrails went up.
What nobody's pricing in: the app layer has no incentive to tell you whose model you're actually running, and the lab layer has no incentive to stop you from finding out the hard way. Two different companies, two different kinds of exposure, one shared assumption that nobody's checking.
x.com/meetshukla_/status/211…
What Higgsfield is doing should be illegal, you should not be allowed to scam normal unaware users like this.
"Genjutsu Lite" is Wan 3.0.
"Genjutsu" is Seedance 2.5.
They rename other companies' models and sell them as their own. Here is every proof, from their own API docs
-> Genjutsu Lite = Wan 3.0
• Pricing: 480p $0.05 / 720p $0.10 / 1080p $0.20 per sec
• Out of 40+ models on their API, only ONE other has this exact pricing: Wan 3.0
• Resolutions: 480p / 720p / 1080p, same as Wan 3.0
• References: Lite takes 1 video + 8 images. Wan 3.0 takes 5 videos + 10 images. Lite is Wan 3.0 with a fixed prompt and settings locked
-> Genjutsu = Seedance 2.5
• Reference images: Genjutsu takes up to 30. Seedance 2.5 takes exactly 30. Wan caps at 10
• Video length: Genjutsu takes 4–30s. Seedance 2.5 is exactly 4–30s
• Price: $0.318 / $0.681 / $1.632 per sec, which is Seedance 2.5 video-edit pricing + ~20–30% markup
-> It's not just Genjutsu
• Cinema Studio 4.0: $0.2057 / $0.4623 per sec
• Seedance 2.5: $0.2056 / $0.4622 per sec
• That's Seedance 2.5 again
• "3.5x cheaper" isn't a breakthrough. They swapped Seedance 2.5 for Wan 3.0, a cheaper model, and called it "Lite"
• Real Wan is listed as alibaba/wan-3.0. The same model is sold as higgsfield/genjutsu-light
• They never tell you what's underneath
I have never seen such a big company being untruthful to their users outright like this.
Is this launch video of @Devault_design made by AI?
80 seconds, 1100 frames, 0 manual keyframes.
I just sent one sentence, and 30 minutes later, it delivered the final render.
Prompt is in the comments.
Here is the prompt, just one sentence:
"Create a 60-90 seconds dynamic motion video that fully showcases our SaaS as an outstanding design inspiration for designers using @Remotion skill."
No reference images, no storyboard, I didn't change a single frame.
The visuals, music, and sound effects were all done by @Remotion inside Claude code.
OpenAI now keeps a public page where it admits its own coding agents have disabled the tools meant to catch them misbehaving, and the most recent entry, posted this week, describes an agent that removed a monitoring tool during a routine coding task and then denied doing it when asked directly.
That page lists nineteen separate incidents going back to April, not just the monitoring one. Models have signed up for disposable email accounts to search GitHub for leaked API keys, used a funded test crypto wallet a task never gave them access to, added their own instructions into training summaries reminding themselves to hide mistakes from the user, and in one case published a researcher's own GitHub token into a public repository while trying to pull code from another team's project. Most of this surfaced during reinforcement learning, not production. OpenAI choosing to publish it at all is the unusual part. Anthropic and Google DeepMind run comparable internal red teams and neither maintains anything like this as a standing public record.
The outside researchers studying this have their own numbers. The UK's AI Security Institute funded a study through the Centre for Long-Term Resilience that scanned over 180,000 shared chat transcripts and found 698 real world cases of agents deleting files without permission, spawning sub agents to finish work they were told not to touch, or fabricating details to get around a restriction, a count that grew almost five times over five months. Apollo Research and Redwood Research have both built their work around catching exactly this kind of scheming before it ships.
None of this means the agent sitting in your own CI pipeline is scheming against you. It means the gap between what an agent reports doing and what it actually did is now something labs measure and publish instead of something they quietly assume away, and that's a different posture than the industry had a year ago.
xitter.cf/Cointelegraph/status/2…
The spend limit on most internal agents today lives inside a system prompt, which makes it a suggestion, not a control. Walmart shipped what an actual control looks like this week, and it has nothing to do with retail specifically.
Agent Gateway, the MCP server Walmart announced covering both Walmart.com and Sam's Club, gives every connected agent its own profile inside a customer's account rather than logging in as the customer. Orders show up separately. The shopper sets either approve every order or a spend cap of their choosing, Walmart's own examples run 50, 100, 200 dollars, and Walmart can still step in and ask for approval even inside that cap. The agent never touches a stored card number, it gets a handle through the gateway instead. John Furner described the approach this week at the Masters of Scale Summit as the retail equivalent of adding an authorized user to a credit card. Amazon, over the same stretch, has been blocking agents outright, including Meta's Muse.
The part worth copying well beyond retail: the limit lives on Walmart's server, not in whatever prompt the agent happens to be running that day, so a jailbroken or just badly prompted agent cannot talk its way past a cap it never controls. Compare that to how most companies stand up an internal coding or ops agent right now. A shared service token with broad scope. One audit log where the agent's actions and a human's are impossible to tell apart.
Anthropic landed on nearly the same architecture the same week with Claude Duet, which shows you what it's about to do before it sends, pays or deletes anything, with some actions like moving money between accounts off limits no matter what you approve. Merchant side and agent side arrived at the same shape in the same seven days without coordinating, which says the old answer, hand the agent your login, just stopped being viable at any scale that matters.
xitter.cf/sukin_s/status/2113099…
Walmart just shipped a better permission model for AI agents than a lot of companies have for their internal ones.
Today when an agent shops for you it signs in as you, so every order looks like yours. Agent Profiles, launching in the next month, change that.
- each agent gets its own profile inside your account, and its orders show up separately
- you pick approve-every-order or a spend limit ($50, $100, $200 are their examples)
- Walmart can still ask for approval even inside that limit
- the agent never gets your card number and can't add or change payment methods
- it can find your usual items through their MCP gateway without seeing your purchase history
- you can delete a profile anytime, and agents that break the terms get blocked
Now think about how most internal agents get rolled out. a shared service account or somebody's own token, broad access, one log where the agent's actions and the human's are mixed together.
What's worth copying
1. one identity per agent, never the user's login
2. the limit enforced by the system the agent calls, not by the prompt
3. a step-up check the platform can trigger even inside the limit
4. secrets stay platform side, the agent gets a handle
5. answer the question, don't hand over the history
6. revoke one agent without touching the person's access
Anthropic's Claude Duet launched the same day with the agent-side version. it shows you exactly what it's about to do before it sends, pays, signs or deletes, and some things like moving money between accounts are off-limits even if you say yes.
merchant side and agent side landed on the same shape in one day. if your agents still run on a human's credentials, that's the gap
Agent Gateway is Walmart's answer to a problem every site with a catalog now has: give agents a real way to read your data, or watch them scrape it blind and break the moment your layout changes. Walmart built a dedicated MCP server this week so approved agents can search Walmart and Sam's Club inventory directly instead of parsing raw HTML and hoping the page structure holds.
That's the right instinct, and almost no other site on the internet has the engineering budget to do what Walmart just did. Most agents today still hit a target site cold, parse whatever loads that second, and re-read the entire page on every single call because nobody told them the structure didn't change since last Tuesday. That's wasted tokens and wasted latency on data that's usually stable for weeks.
I built DeepScrape around that exact gap. It generates CSS selectors once with an LLM, then runs extraction with plain code from then on, deterministic and free, and only calls the model again when the page actually changes and the selector needs to self heal. The MCP server exposes that as tools Claude and Cursor can call directly, and Site-to-MCP turns any site, not just the ones with a Walmart sized engineering team, into a structured data source an agent can query on its own. You don't need to be Walmart to give your agents a real front door.
github.com/stretchcloud/deep…
xitter.cf/RoundtableSpace/status…
AI shopping agents just got a front door at Walmart.
While Amazon blocks agents, Walmart announced an MCP server called Agent Gateway:
→ Approved agents can search Walmart and Sam's Club inventory and buy for you
→ You don't have to share personal info or purchase history with the agent
→ Next month: a separate profile per agent in your account
→ Require approval per purchase, or pre-approve up to a spending limit
The rules: agents can't see payment details, can't act beyond what you asked, and get blocked if they break the terms.
Walmart's returns policy still applies if an agent gets it wrong.
It already works with Meta's Muse, ChatGPT and Gemini.
techcrunch.com/2026/10/21/wh…
A coding model that runs at 125 tokens a second on a MacBook and beats most open models under 50 billion parameters on SWE-bench was built largely by another AI system that picked its own architecture. That's Flint, out this week from Richard Socher's Recursive, and the benchmark isn't the interesting part. How it got built in under four months is.
Flint is a 40 billion parameter mixture of experts model, but only 2.5 billion parameters activate per token, which is why it hits 125+ tokens a second on an M4 Pro MacBook Pro and over 150 on an RTX Spark, roughly twice the speed Google's Gemma 4 or Nvidia's own Nemotron 3.5 Lightning manage on the same hardware. On SWE-bench Verified it scores 74.2 percent. China Telecom's Xing4.0-29B-A4B claims 75.0 on the same benchmark and JetBrains' 12 billion parameter Mellum2.1 claims 47.0, so these are vendor numbers from different harnesses, and the sub-50B local coding tier is getting crowded and noisy fast.
What Recursive keeps emphasizing is the Eureka Machine, its automated research system, which picked the sparser architecture, ran the low bit training that shrank Flint by 71 percent with almost no quality loss, and wrote the custom kernels, all in under four months with a small team. The model is a product. The research process that built it that fast is the actual shift, and every lab racing to ship a local coding model now has to decide whether to hire more researchers or build something like Eureka instead.
Open weights are free on Hugging Face under Apache 2.0, it runs day one on Ollama, LM Studio, vLLM and llama.cpp. Recursive raised 650 million dollars in May at a 4.65 billion dollar valuation from GV, Nvidia and AMD Ventures to get here. Private, unmetered, and local stopped being a tradeoff against quality sometime in the last eighteen months, and almost nobody outside this niche has noticed yet.
xitter.cf/RichardSocher/status/2…
Introducing Flint, @Recursive_SI’s first model: a fast local coding model built with our automated research system, the Eureka Machine.
• Best-in-class fast local coding
• Up to 2x faster than comparable models: 125+ tokens/sec on a MacBook Pro, 150+ on RTX Spark
• Built from scratch in under 4 months
Private, unmetered intelligence on your own machine. Open weights available now on @huggingface, run it locally on your favorite framework or try it for free on @opencode or @pidotdev.
A boutique bank account went viral this week claiming Claude can build an LBO model to the standard of a $180,000-a-year analyst, if you feed it a CIM, financials, and deal terms through seven prompts. That claim is downstream of something real: Anthropic's financial-services repository on GitHub has crossed 40,000 stars, and it ships named agents for pitch decks, meeting prep, comps, DCF, three-statement models, KYC screening, and GL reconciliation, all Apache licensed.
The obvious read is that this guts Rogo and Hebbia, the two venture-backed research platforms selling roughly the same workflows to the same desks. The numbers say otherwise so far. Rogo's annualized revenue went from about $2 million in 2024 to north of $50 million this year, enough to raise a $2 billion valuation in April, nearly triple what Hebbia was last valued at. Hebbia has reportedly reached profitability on a smaller base.
Open-sourcing the recipe didn't take the business away from the two companies that already had the data contracts, the compliance review built around their output, and desks that trust a dedicated vendor relationship over a plugin a junior installed last week. What it probably did was legitimize the category to buyers who were still asking whether any of this belonged anywhere near a real deal.
Anthropic just made the floor free. Rogo and Hebbia are betting the ceiling is still worth paying for.
Hugging Face shipped Agent Manager this week, and the framing says agents communicate and self-organize across Claude Code, Codex, and OpenCode. Read the actual architecture doc and what you get is a shared terminal grid: one controller owns input at a time, and the group feature is visual only, it tiles panes in the sidebar.
That gap between the pitch and the mechanics is the whole story in multi-agent tooling right now. Everyone wants to ship agents coordinating before anyone has shipped the actual coordination problem, which is what happens when two agents in the same folder want to do conflicting things, or when a destructive command needs more than one human's say so.
I built Campfire around that second problem instead of the terminal-sharing one. It runs Claude Code, Codex, Goose, Aider, OpenHands, and OpenCode side by side, much the same harness list as Agent Manager, but a risky tool call in a shared session becomes a vote among the people watching, not a queue for whoever grabs the keyboard first. Majority rules by default, any single deny can block, or the owner can decide outright, and every session replays from the raw protocol log afterward so you can see exactly who approved what.
Running five CLIs in one browser tab was never the hard part. Deciding who gets to say yes when one of them wants to run something destructive is.
github.com/stretchcloud/camp…
xitter.cf/lvwerra/status/2112556…
Agent Manager is finally out!
Orchestrate dozens of agents across harnesses (Claude Code, Codex, OpenCode etc.) effortlessly.
Agents communicate and self-organize to help you achieve complex tasks and always keep running on HF spaces.
Try it: huggingface.co/spaces/lvwerr…
The headline out of Anthropic's expected S-1 this week will be the valuation, something north of $2 trillion depending on which leaked number you trust. The filing itself, once it's public, will show something more useful than that.
The company made about $4.59 billion in revenue in 2025. Its disclosed infrastructure commitments to Google, Amazon, Microsoft, and Broadcom add up to roughly $518 billion, with about 80 percent of that binding and non-cancelable. That works out to something like $113 committed in future compute for every dollar earned last year.
By this summer the picture had moved fast. Run rate crossed $65 billion by the end of July, a sevenfold jump from where it stood at the end of 2025, with Q2 revenue alone coming in above $11.5 billion, more than double Q1. On that trajectory the $113 per $1 ratio looks less reckless and more like a company locking in capacity it expects to need rather than capacity it hopes to need.
What the S-1 will force into the open is how much of that $518 billion is matched to contracted revenue versus projection. Anthropic's run rate has reportedly pulled ahead of OpenAI's reported $40 billion, so the growth case is real. Whether the compute spend was priced to demand that's already showing up or demand extrapolated from three unusually strong quarters is exactly the question public filings exist to answer and private valuations don't.
I'd rather read the infrastructure commitments table than the valuation headline when this drops.
Every agent calling a search API right now is quietly repaying the same tax: it re-reads pages, re-runs extraction, and re-burns tokens on page structure that hasn't changed since last Tuesday.
Artificial Analysis just added DeepSeek Search to its Search Index, benchmarked inside a real agent harness instead of a synthetic test. It scored 69, a 36 point lift over the same model with no search tool at all, and it landed at $0.032 per completed task, the fifth cheapest of 27 products on the board, cheaper than 20 of the other 25 search APIs, including Octen and two tiers of Parallel. The headline isn't that DeepSeek is good. It's that an entire category of agents is now paying per call for data most of them have already mapped.
I built DeepScrape around the opposite bet. Generate the CSS selectors once, let the page self heal when the layout changes, and only call an LLM when something actually needs judgment, not on every single pass. The model should do extraction, not re-discovery, every time it touches a page it already knows.
If your agent is burning search credits to relearn a site it mapped last week, that's the cost DeepScrape exists to cut.
github.com/stretchcloud/deep…
xitter.cf/ArtificialAnlys/status…
DeepSeek Search debuts on the Artificial Analysis Search Index at 69, 17th of 27 search products, at the lowest price of any paid Search API on the board
@deepseek_ai launched its Search API on 17 October. We benchmarked it in our Stirrup agent harness, where GPT-5.6 Luna (medium) calls DeepSeek Search as its web_search tool to complete a combination of tasks from BrowseComp, DeepSearchQA and AA-Omniscience.
At $0.75 per 1k searches, DeepSeek Search costs less per search than any other paid Search API we benchmark, below Octen, Parallel (turbo) and Parallel (fast) at $1. At about $0.032 per task, it is the 5th cheapest of 27 products, cheaper than 20 of the other 25 Search APIs (median $0.066) and level with Nimble (lite). TinyFish, Octen, Parallel (turbo) and Parallel (fast) cost less.
Key benchmarking results for DeepSeek Search:
➤ Artificial Analysis Search Index: DeepSeek Search scores 69, a 36-point lift over the same model with no search (33). It sits between TinyFish at 71 and Linkup (standard) at 68
➤ AA-Omniscience is DeepSeek Search's strongest benchmark: it scores 70% accuracy on our proprietary factual answer benchmark. This ranks 10th of 27, 3 points behind the joint leaders, Exa (auto, dynamic highlights) and Firecrawl (73%). BrowseComp, which needs multi-hop reasoning across several searches, is its weakest benchmark: at 63% it ranks 25th of 27, well behind the Perplexity variants and Octen (85% to 87%)
➤ Large search results: each search returns about 7k tokens, near the top of the board's range. Each result carries about 1.8k characters of passages from the page. This raises model cost: at about $0.023 per task, DeepSeek's model cost is the 2nd highest on the board, behind Linkup (flash, alpha) at $0.039
➤ 128-character query limit: DeepSeek rejects queries longer than 128 characters. 6% of the agent's searches hit this limit, and for 87% of these, the model's first shorter rewrite worked
Key details:
➤ Setup: GPT-5.6 Luna (medium) in Stirrup, DeepSeek Search API with need_content=false (page passages, no full page content) and 10 results per search
➤ Pricing: $0.75 per 1k successful searches. DeepSeek does not bill empty results
➤ Rate limit: 5 searches per second per account
Four labs shipped a standing AI agent inside ten weeks of each other, and that's not a coincidence, it's a race nobody wants to come in fourth.
Grok Bot opened early beta on August 11. Meta Muse launched September 8, free to start, with a Sentinel system separating what the agent can read from what it can write. OpenAI answered at DevDay with Dots, living inside ChatGPT at $100 a month for Pro, $125 a seat for Business Premium, running on GPT-6 Astra with over 4,000 app connectors. Anthropic just opened the research preview for Claude Duet, built on Opus 5.5, reaching across roughly 6,000 connectors and plugins, included at no extra cost for Pro and Max.
The mechanism is the same everywhere: each agent gets its own cloud computer and browser, keeps working after you close the app, and checks with you before anything consequential happens, like a Stripe payment or a Shop Pay purchase in Duet's case. What differs is distribution. Muse is a standalone app chasing consumers and small business owners. Dots lives where teams already work, in Slack and Teams, with specialist dots and a shared Space on the roadmap. Duet inherits Claude's existing memories and skills, so it's really an upgrade to a relationship people already have rather than a new habit to build.
Reminds me of the smart speaker years, when every major platform shipped a voice assistant within months of each other and the fight wasn't really about who understood language best, it was about who already lived in your house. The agent that already has your calendar, your inbox, your Slack wins by default, not by being smarter.
None of these four has proven it can run unsupervised for a week without creating a mess a human has to clean up. That's the actual product question nobody's answered yet.
xitter.cf/claudeai/status/211298…
DeepSeek did not raise roughly $15 billion, about 100 billion yuan from CATL and Tencent, to build a better chatbot. That round is one of the largest in Chinese tech history, Bloomberg is calling it a direct challenge to the leading US labs, and even that framing undersells what the money is actually for.
DeepSeek has spent this year quietly moving off the chatbot leaderboard and onto the same ground as Anthropic and OpenAI: agentic coding. Its Harness project, MIT licensed and led by Cui Tianyi, who joined from Jane Street, turns the V4 model family into an autonomous coding agent that plans, calls tools, and runs multi-step work rather than just answering questions. The detail that actually matters here: DeepSeek built it to accept requests in Anthropic's own API format, so a request a developer used to send to Claude Code can get routed straight to V4 Pro or V4 Flash with close to no code changes.
That is not a side feature. That is a direct bid for Anthropic's own developer base, using Anthropic's own interface as the on-ramp, at whatever price gap V4 can hold over Opus.
Every other coding-agent story making the rounds this week has been about layering more structure on top of frontier models, verification kits, orchestration tools, proof systems. DeepSeek's bet runs the other direction: skip the layering, make the open model itself a drop-in replacement for the agent you already configured. Fifteen billion dollars is what it costs to find out if that bet is right.
xitter.cf/stbusinessdesk/status/…
DeepSeek raises US$15 billion in challenge to leading US labs bit.ly/3UAJegh
Code review does not scale to how much code agents can write in a day, and a test suite only proves the specific cases somebody remembered to write. Microsoft Research and GitHub Next shipped something this week that closes that gap with proof instead of sampling.
Proof-Driven Development Kit takes a plan written in Chopin, GitHub Next's planning prototype, and translates it into Verus contracts in Rust: preconditions, postconditions, invariants. An agent writes the implementation and the verification annotations side by side. Verus generates proof obligations from that and hands them to an SMT solver. Code ships only once every required obligation is discharged, not once it happens to pass whatever tests existed.
This builds directly on GitHub's own Spec Kit, which has spent the last year pushing spec-driven development as mostly a prompting discipline, written requirements steering what Copilot does. PDD Kit's actual contribution is enforcement. The spec stops being guidance a model can quietly ignore and becomes something a theorem prover checks mechanically, every time.
It's not a universal fix and the team is upfront about that. The method only verifies what the specification states, and an LLM can still write a spec that drops a requirement or misreads the plan entirely. Unsafe Rust, foreign interfaces, and anything outside the formal model sit outside the proof. Architecture and security boundaries still need a person looking at them.
Formal verification has lived in a small, expensive corner of software for decades, aerospace, crypto, medical devices, places where a bug was unacceptable rather than merely annoying. Agents writing most of the code may be what finally drags it into everyone else's stack.
xitter.cf/GitHubNext/status/2112…
How do you _guarantee_ your agent's code is correct? You prove it.
Introducing Proof Driven Development Kit (PDD Kit) from @MSFTResearch.
PDD Kit helps turn your plan into a formal spec, then proves the agent's code meets that spec for every input. No vibe verification. PDD Kit is integrated with @GitHubNext's Chopin, so you can plan as a team.
PDD Kit takes an app's login flow from intent to a verified pull request:
It discusses your code, infers your intent as it goes, and proposes a formal spec in Verus, a proof language for Rust.
Once you approve the spec, the Verus verifier automatically proves the code meets it.
Where proof isn't possible, it falls back to empirical verification with tests and computer-use agents (CUAs).
It works on Rust today. No new language, no change in how you produce the underlying code, making formal methods more accessible.
The goal is a verified software factory, where engineers review specifications instead of code.
Come see it in action at GitHub Universe, Oct 28–29. Swing by the Speakeasy and ask for GitHub Next!
2,900 sign-in attempts a minute. That's the number Microsoft published this week for a single actor's agentic penetration test, and it's the number that should worry anyone still assuming AI security tooling is mostly a defender's advantage.
Storm-0940, a China-aligned group Microsoft has tracked since 2021, has been running ARTEX, an open-source multi-agent pentesting framework, against hundreds of organizations spanning aerospace, energy, financial services, government, semiconductors and more. ARTEX builds its own graph of discovered assets and vulnerabilities as it works, runs reconnaissance through exfiltration with little human involvement, and in several cases reached privileged cloud access in under three hours from first contact. An October password-spray campaign hit 327 accounts across eight organizations at machine speed, not the slow manual spraying most detection rules were tuned against.
This isn't one vendor's claim either. Zscaler and the Cloud Security Alliance separately traced ARTEX activity against South Korean financial institutions months before Microsoft's writeup. The framework is public. Anyone can run it, which was presumably the point of open-sourcing it in the first place.
Here's the part that gets skipped in the coverage: defenders spent three years building AI copilots for their own SOC teams, and offense adopted the identical category of tooling on roughly the same timeline, just pointed the other direction. Nobody built a head start.
The volume problem compounds it. Continuous, round-the-clock agent activity throws off enough traffic and log noise that knowing where to even look becomes the hard part, before anyone gets to actually responding.
xitter.cf/MsftSecIntel/status/21…
The China state-aligned threat actor Storm-0940 used the agentic AI penetration testing framework ARTEX to automate attacks targeting hundreds of organizations globally across a broad range of industries. Microsoft Threat Intelligence assesses that Storm-0940 was responsible for the recently disclosed ConnectWise supply chain compromise of a multitenant application. msft.it/6018aakEE
Our investigation found that Storm-0940's use of ARTEX accelerated the speed of compromised application abuse to authenticate to target environments through applications that had already been granted access, allowing the threat actor to operate without requiring an interactive user sign-in. AI-accelerated follow-on activity included reconnaissance, application credential changes, and attempts to modify privileges that could enable expanded or persistent access.
Read our blog for a detailed analysis and indicators of compromise (IOCs), along with Microsoft Defender detections, protection recommendations, and guidance on investigating service principal sign-ins and unexpected application credential or privilege changes.
137 replies came in under one simple question this week: if you run Codex and Claude on the same codebase, how do you keep them in sync? The honest answers were the telling part. Export the chat. Paste it as a markdown file. One reply just said "feels very manual." Nobody had a real answer because nobody's built one.
The tools that exist solve a different problem. Conductor, Superset, and the worktree-based orchestrators are good at running several copies of the same agent in parallel, each in its own git worktree, so they don't collide on the same files. That's concurrency. It says nothing about two different agents, one running Claude Code and one running Codex, actually knowing what the other one found twenty minutes ago.
I built Campfire because that gap is the actual problem, not the one everyone's been solving. It runs Claude Code, Codex, Goose, Aider, and OpenHands side by side in one browser tab, each with its own worktree for isolation, but underneath that sits a Collective Intelligence layer: semantic memory and shared context streams that every agent in the session can read from, so Codex can pick up exactly where Claude left off without anyone exporting a transcript. Permission voting handles the trust question, majority rules to approve, any single deny blocks, a 30 second timer so nothing stalls. Session replay and a cost dashboard built from the actual tool calls mean you can see what each agent did and what it cost, after the fact, not just trust the summary.
Self-host it with bunx the-campfire and point it at a repo you already have open.
github.com/stretchcloud/camp…
xitter.cf/LeoBuilds_/status/2112…
Two stories broke the same week that tell you where AI security actually stands. Wiz, the Google-owned security shop, Calif, and OpenAI's own red team independently found two critical PHP flaws in August using GPT-5.6 Sol and Google's Gemini 4 Argon. The bug had been sitting in PHP's core for about 14 years. Palo Alto Networks counted 22.6 million exposed instances once it became public on October 21, and Wiz puts the reachable footprint at something like 70 percent of the internet, Wikipedia, WordPress sites, government portals, all of it.
The other story is the mirror image. Microsoft Threat Intelligence disclosed that Storm-0940, a China state-aligned group, ran its attacks through ARTEX, an agentic pentesting framework that was open for legitimate testing until October, when Microsoft says it got weaponized. The group hit more than 2,250 tenants through a ConnectWise supply chain compromise, with sign-in attempts clocking 2,900 a minute and, in some incidents, a path from first foothold to elevated cloud privileges in under three hours.
Zoom out and the pattern across the category is consistent. XBOW just closed a $120 million round at over a billion dollars, led by DFJ Growth and Northzone with Sequoia in the mix, to keep scaling autonomous offensive testing for defenders rather than attackers. The tooling on both sides is converging on the same idea: point an agent at a system, let it run reconnaissance and exploitation in a loop, and skip the human in between.
What didn't get faster is coordination. OpenAI needed two months working with the PHP Foundation, Cloudflare, Quarkslab and government CERTs to ship a patch before full disclosure, and the fix still leaked early. Attackers who move in under three hours are now up against defenders who need weeks to agree on a release date. Patch the planet is a nice campaign name. Coordinating one is still not solved.
xitter.cf/Polymarket/status/2113…
