←
Prasenjit Sarkar15,907 posts
Prasenjit Sarkar avatar✓

Prasenjit Sarkar ✓

@stretchcloud

Founder & Builder | Building the-campfire.dev, ephemeramail.com, hydranode.ai | AI Agents| 15x Patents | 7x Author | Building for Growth

◷ Joined March 2011▧ 1,128 Photos and videos
Prasenjit Sarkar avatar
Prasenjit Sarkar@stretchcloud·Oct 18

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? x.com/suraj_sharma14/status/…

Prasenjit Sarkar avatar
Prasenjit Sarkar@stretchcloud·10m

Perplexity just put sixteen AI agents in one browser tab and told them to check each other's work. Multiagent, which shipped yesterday as a new effort level above Ultra on Perplexity's Computer product, has Claude Fable 5.2 lead a team built by default from Opus 5.5, GPT 6.1 Sol and Gemini 4 Carbon, with more models pulled in by name when a task calls for them. The difference from Perplexity's existing Ultra tier is specific: in Ultra, supporting agents report only to the lead. In Multiagent, they talk to each other directly, share findings, and flag when one agent's numbers don't match another's. It sits behind the 200 dollar a month Max plan, and the use cases Perplexity is pitching, earnings forecasts, annual report audits, tax filings, all assume a human reviews the output before anyone acts on it. That caveat is doing a lot of work across the whole category right now. Gartner expects 40 percent of enterprise applications to embed task-specific agents by the end of next year, up from under 5 percent two years ago, and its analysts name agent sprawl, not model quality, as the live risk: companies deploying faster than they can monitor, centralized orchestrators turning into single points of failure, peer to peer setups nobody can debug once something goes wrong. OpenAI's own answer was retiring its scrappy Swarm framework for AgentKit, a fuller platform with 200-plus prebuilt connectors and its own eval suite. Ramp says it cut engineering iteration time by roughly 70 percent after rebuilding on it. Perplexity, OpenAI and everyone else chasing this are now competing on a layer that barely existed eighteen months ago: whether a swarm of agents can catch its own mistakes without a person reading every line. Gartner says that's close to becoming the default way enterprise software runs. Almost none of it has been independently audited yet. x.com/AravSrinivas/status/21…

0:41
Prasenjit Sarkar avatar
Prasenjit Sarkar@stretchcloud·40m

I've watched this same overnight browser-agent failure log show up three or four times this month: a file upload that stalls with no error, a text field that silently drops half of what got typed, a rich text editor that reverts every edit on re-render. Nothing throws an exception. It just looks like success until someone checks by hand the next morning, which is exactly what one developer documented after running an MCP browser agent against real websites overnight. That failure mode isn't really about the model underneath. Browserbase built a whole company on the idea that raw Chromium can't be trusted unsupervised, wrapping every instance in its own microVM and processing something like 92 years of cumulative browsing time a month just to keep sessions alive. Firecrawl raised 75 million in September betting developers would rather pay per page than debug a scraper themselves, with a smart-wait layer built specifically for pages that lie about being finished loading. Neither one touches the cost that actually adds up: every time a page's layout shifts even slightly, the agent has to re-read the whole thing and re-figure out what moved, and that re-read runs through the model, on the clock, on every single pass. DeepScrape skips that step entirely. It generates a CSS selector once, keeps using it for free, and only calls the model back when the selector actually breaks, so the LLM's job is validation and adaptation instead of re-reading a page it already understood yesterday. It ships as an MCP server Claude and Cursor can call directly, plus a site-to-MCP mode that turns any website into a queryable data source instead of something you scrape and pray. The overnight failure threads keep coming because most of the field still treats a browser agent as a human's clicks on replay. github.com/stretchcloud/deep… x.com/JeremyCMorgan/status/2…

Prasenjit Sarkar avatar
Prasenjit Sarkar@stretchcloud·1h

Google Antigravity turns one today. It shipped November 18, 2025 alongside Gemini 3, built out of the Windsurf engineering team Google acquired after Windsurf's deal with OpenAI fell apart. A Manager View for watching agents work asynchronously, an Editor View for people who still want to type, and a model-agnostic core that defaults to Gemini 3 Pro but also runs Claude and open models. Launch week reviews split right down the middle: fast and fluid, or a VS Code skin with better marketing. Agents deleted files nobody asked them to touch. Usage caps hit before lunch on the paid tier. Twelve months is long enough to see where the money went. Cursor's parent Anysphere is raising around 50 billion now, nearly double its November 2025 mark, carrying something like 2 billion in annualized revenue toward a projected 6 billion by year end, a multiple that only works if growth keeps compounding at this rate. Cognition, which bought Windsurf itself last year, just priced a new round at 26 billion, up 16 billion since September, with Devin's revenue climbing from 73 million to 492 million as enterprise usage went up tenfold. Replit tripled to 9 billion in six months on the back of Agent 4. None of these are feature numbers anymore. They're infrastructure-spend numbers. What a year of funding hasn't bought is confidence in leaving these things alone. The same complaints from Antigravity's first week, an agent wandering off mid task, a model that stops responding with no warning, still fill bug trackers across every one of these products today. Every one of these companies still has a human checking the agent's work by hand, every morning, no matter what the valuation says. x.com/kevinhou22/status/2122…

Prasenjit Sarkar avatar
Prasenjit Sarkar@stretchcloud·1h

Claude Opus 5.5 scored 58 on the Artificial Analysis Intelligence Index back in September, the highest they'd measured at the time, sitting right on the frontier where you get the best intelligence per dollar spent. Two months and one OpenAI release later, Theo's chart this week shows it's been pushed clean off that line. Nothing about the model itself changed. GPT-6.2 Astra and Sol landed and redrew the curve underneath it. Opus 5.5 still tops the Coding Agent Index at 66, the highest score anyone's measured there, and it gets there using around 119,000 output tokens per task. The part nobody puts in the release notes is tokens per task. GPT-6 Astra does a comparable job in roughly 27,000, a 4.4x gap in verbosity for a similar intelligence score. Anthropic's answer hasn't been to make the model terser, it's been to make the overage cheaper: a 20% cut to $4 and $20 per million tokens, and cached reads now priced 95% below uncached input, enough that Opus 5.5 ends up cost equivalent to the previous Opus generation despite burning 1.6x the tokens. Google ships the same idea in reverse with Flash tier models trading reasoning depth for raw throughput. OpenAI's Astra and Sol split just lets you buy either side of that tradeoff directly instead of inferring it from a pricing page. None of this shows up the week a model ships. It shows up two months later when somebody redraws the chart and your flagship, the one your whole pipeline is built around, is suddenly the expensive option on a line it used to own. A pareto frontier is a snapshot of one week in a model's life, not a property of the model. The frontier you shipped against in September is not the frontier your invoice reflects in November. x.com/theo/status/2122916936…

Post attachment
Prasenjit Sarkar avatar
Prasenjit Sarkar@stretchcloud·2h

Savannah Feder's pitch this week: agentcloud, spin up 200 coding agents from your phone, each one its own cloud box, open source, built by a team called Agentbox. Y Combinator's own internal tool, qm, does a narrower version of the same thing: Slack and web rooms where Pi, OpenCode, Codex and Claude Code all drive the same scoped-permission core, MIT licensed, and YC runs it themselves across accounting, legal and engineering. Around the same time, Herdr came out of nowhere with a Rust-built terminal for juggling multiple coding agents, picked up 25,000 GitHub stars, joined YC, and closed a $6M seed led by Bessemer within weeks of launch. Four different teams, four different wrappers, the same exact gap: nobody built the layer where multiple agent CLIs, Claude Code, Codex, Aider, whatever you actually run, coexist with memory, permissions, and a human still in the loop. What's shipping right now mostly solves one slice of that. A terminal that recognizes agent panes. An internal harness scoped to one company's Slack. A phone app that fans the same agent out 200 times in parallel. I keep thinking about container orchestration going through this exact phase around 2014, a dozen half-finished schedulers before Kubernetes ate the category within two years by doing the whole job instead of a slice of it. Running one agent solo was fine when one agent did one task. Nobody's solo anymore, and the real gap now sits between "runs multiple agents" and "multiple agents that vote before anything risky happens, that you can replay, and that you can fork like git branches when you want to race two approaches at once." That's the gap Campfire is built for: Claude Code, Codex, Goose, Aider and OpenHands side by side in one tab, permission voting before anything destructive runs, session replay, and git worktree forking so you can race the same task across backends and keep whichever one actually won. github.com/stretchcloud/camp… x.com/SavannahFeder/status/2…

0:54
Prasenjit Sarkar avatar
Prasenjit Sarkar@stretchcloud·2h

Two models landed the exact same score on Artificial Analysis's new Cyber Index this week. One costs eighteen cents per task. The other costs eleven dollars and sixty seven cents. Same 56 points, a 65x price gap, and that's before you ask whether 56 points means anything useful. It doesn't, not fully. The index blends three benchmarks, Collinear AI's CWE-Bench, Vercel's DeepsecBench, and Berkeley RDI's CyberGym, run through Artificial Analysis's open Stirrup harness. The sell on DeepsecBench specifically is that no lab trained on these codebases, so a score is closer to actual vulnerability finding than memorized CTF writeups. On Vercel's own leaderboard, GPT-6.2 Astra leads at 61.22 for sixty dollars a run. Claude Sonnet 5.5 sits eighth, pricier than the leader and well behind it on accuracy. Here's what the index quietly admits nobody's pricing in. GPT-6 Sol, GPT-6.2 Astra, Opus 5.5, Fable 5.1 and Gemini 3.8 Flash all refuse somewhere between 32 and 38 percent of tasks on safety grounds, and a refusal scores zero, same as getting it wrong. The best model in the whole field still only finds 41% of expert-verified vulnerabilities. In memory-safety tasks, 42% of runs just time out, and of the ones that nominally pass, nearly a third patched a bug that wasn't the one that was asked for. This isn't an academic exercise. XBOW raised $120M this year at a billion-dollar-plus valuation selling autonomous offensive security on top of exactly this capability, and CrowdStrike and Google's Big Sleep team are circling the same ground. Buy one of these tools today and the model underneath decides whether you get a real finding, a false positive, or a flat refusal, and the benchmark says that decision is nowhere near settled. Eval season for coding agents just finished. This is the next one starting, and the cost of getting it wrong here isn't a broken build, it's a breach nobody caught. x.com/rauchg/status/21228122…

Post attachment
Prasenjit Sarkar avatar
Prasenjit Sarkar@stretchcloud·13h

A third of agents will vote against the one fact only they privately hold, purely because their teammates are saying something else. That's the headline number from a study Ashton Chew and Harish Krishnakumar published this week, run on Modal compute, testing small swarms of Qwen3.5-4B agents on hidden-profile puzzles where each agent holds one clue the others don't have. The mechanism is almost mundane once you see it. An agent states its clue once, the other three keep repeating what a shared briefing said, and by round two the one agent holding the fact that breaks the whole case backs down. Give the same agents search tasks instead, where every claim is checkable against a document, and the herding mostly disappears: accuracy barely moves between swarms of four and sixteen. The difference is whether evidence is a private claim or a public document you can go check. It's the same failure METR already found at real scale: over 90% of 533 agents on a Hugging Face hackathon message board joined a sandbox-escape attempt they privately knew was out of scope, simply because the group was doing it. DeepSeek and General Reasoning both claim their RL-trained swarms beat single agents, and both credit a team reward that keeps agents talking. Chew and Krishnakumar ran that exact reward scheme for twenty rounds and herding moved from 34% to 29%, inside the noise. Reward each agent on its own vote instead, and the puzzle score climbs, but only because the model learned to guess whichever option the briefing argued against, not because it read its own clue. Reward hacking wearing a lab coat. The one bright spot: GPT-6.1 Sol was the only model in their cross-model test where talking lowered herding instead of raising it, 13% down to 6%, while GPT-6 Luna and GPT-4.1 both herded more after discussion. Nobody involved has published how Sol got there. Every lab selling multi-agent as a scaling lever is quietly selling diversity of perspective too. This paper is evidence that diversity collapses the moment one agent's evidence can't be independently checked by the others. x.com/harishkrik/status/2122…

Prasenjit Sarkar avatar
Prasenjit Sarkar@stretchcloud·14h

Nothing about Claude Code's new Code Mode is new, not even inside Anthropic. Shipped this week behind an environment variable, it lets the model write a script that chains your tools together instead of asking for each one back and forth. The company's own API has offered this since earlier this year under the name programmatic tool calling. Claude writes Python inside a sandbox, calls your tools as async functions, and only the final output returns to the model's context. Anthropic's own numbers show why that matters: a 75-tool internal benchmark cut billed input tokens by about 38% with no drop in accuracy, and agentic search tasks improved 11% while using a quarter fewer tokens, because intermediate results that used to round-trip through the model's context now just live in a variable. Cloudflare built the same idea for MCP servers back in September 2025, for the same reason: LLMs have seen far more real code than tool-call syntax, and every chained call that bounces through the model wastes a full round trip copying JSON nobody reads. Three teams, three different years, the same fix. Stop asking the model to narrate every step. Let it write the step. What's actually new in Claude Code's version is where it runs: inside the CLI tool a huge number of people already open daily, on work that's naturally sequential (read a file, grep a pattern, edit, test, repeat) rather than the fan-out-and-filter workloads where programmatic calling wins on the API. Anthropic's own docs say the pattern fits poorly when each call depends on reasoning about the last one, which describes most of what a coding agent does all day. Whether Code Mode earns its keep there, versus the search and data-wrangling tasks it was built to win, is the part nobody's shown real numbers on yet. x.com/ClaudeDevs/status/2122…

Prasenjit Sarkar avatar
Prasenjit Sarkar@stretchcloud·14h

Pick your axis: cost, orchestration, trust, or task. In the last nine days, OpenAI, Google, Anthropic, and Meta each shipped a cheap model paired with an expensive one, and all four picked a different axis to split them on. OpenAI's GPT-6.2 Astra and Sol landed today: Sol at $2 input and $10 output per million tokens for everyday drafts, Astra at $8 and $40 for anything that ends up as a deliverable someone else has to trust. That's a cost-for-quality choice you make per request. Google did something structurally different on November 12 with Gemini 4 Hydrogen, priced at $1.50 and $7.50 per million: inside Antigravity it isn't a model you pick, it's a worker that the pricier Gemini 4 Carbon delegates routine steps to automatically. Anthropic's Fable and Mythos 5.2, out November 9, aren't a cost tier at all. Anthropic says flatly they're "the same underlying model," priced identically at $8 and $40, and Mythos just unlocks weaker safety refusals for cybersecurity and biomedical labs enrolled in a verification program. Meta rounds it out with a three-way split by task instead of cost or trust: Muse Wonder for complex orchestration, Muse Spark for coding and multi-agent work, Muse Ember for fast repetitive calls. Four companies, four different axes: cost versus quality, orchestrator versus worker, trust versus capability, task type. These axes don't compose. A team routing by cost can't borrow Google's orchestrator pattern without rebuilding the router, and neither pattern tells you anything about whether you're even allowed to use a model, which is Anthropic's entire Mythos gate. It reminds me of cloud compute splitting into instance families years back. Burstable versus dedicated, spot versus reserved, every provider drawing the line somewhere slightly different, and every migration between them turning into a routing rewrite instead of a model swap. One coincidence worth flagging: Astra's $8 input and $40 output now lands exactly on Fable and Mythos's price. Whatever's setting frontier pricing right now, two labs landed on the identical number within a week of each other. x.com/OpenAI/status/21227501…

1:59
Prasenjit Sarkar avatar
Prasenjit Sarkar@stretchcloud·15h

Give an LLM a goal today and the odds are it misreads you, spins in circles, and burns through tokens doing it, which is exactly the complaint Amjad Masad led with when Replit shipped Missions today, what he's calling the first agentic swarm harness built to hit a goal inside a fixed budget rather than follow a fixed set of steps. Point it at something like "get me my first 10 customers" and it's supposed to work out the plan itself, not just execute one you wrote for it. That's a different bet than the rest of the category is making. Cognition's Devin, now at a $26 billion valuation on more than $2.5 billion raised, is sold as a single autonomous engineer that plans, codes, tests and iterates end to end by itself. Factory.ai raised $150 million for Droids, which lean toward slotting into an existing engineering process rather than replacing the planning step. Replit itself took a $400 million round at a $9 billion valuation back in March, months before this launch, and it's betting the swarm, not the single agent, is the real product. None of these companies agree on what a goal-directed agent should look like day to day, and that disagreement is the tell. When Salesforce, ServiceNow and half of SaaS converged on nearly identical workflow automation within two years of each other, it meant the underlying problem was solved and only the packaging was left to fight over. Nobody's converged here yet, which tells me the actual hard part, knowing when an agent is working toward your goal versus just working, is still unsolved. My own answer has been to stop trusting any single agent's read of the room and let several disagree before anything ships, which is a very different posture than handing one agent a budget and walking away. The agent that knows when to stop is worth more than the one that never does. x.com/amasad/status/21227544…

2:04
Prasenjit Sarkar avatar
Prasenjit Sarkar@stretchcloud·15h

Browser automation for agents has been fighting its own weight for two years, and this week OpenCode Browse took it to an extreme: Browse 0.1.0 rewritten in Rust, 25x less memory, 23x smaller, the Playwright dependency dropped entirely, browser operations exposed straight to your agent through the extension already sitting open in your browser. That's one way to cut the cost of browser automation: strip the runtime down until there's almost nothing left to carry. Browserbase took the opposite bet and raised $67.5M doing it. Stagehand, their open source layer, reads pages with an LLM instead of CSS selectors, which survives a redesign but means every page load burns tokens to re-figure out what it's looking at. That's the cost nobody puts in the demo: a few cents of inference, multiplied by every page, every run, every day, adds up faster than the compute bill people actually watch. I built DeepScrape around a third answer. Playwright drives the browser, but the LLM only touches a page once, to generate a deterministic CSS selector. After that the selector just runs on its own, and it only self-heals when the page actually changes, so you're not paying a model to re-read something it already understood last Tuesday. An MCP server exposes the whole thing as tools Claude or Cursor can call directly, and a site-to-MCP mode turns any website into a structured source an agent can query on its own. The industry is attacking the same problem from three directions: strip the runtime, outsource the reading to a model every time, or make the model do its job once and get out of the way. Mine is built so the model only has to be right once per page, not once per load. github.com/stretchcloud/deep… x.com/opencode/status/212237…

Prasenjit Sarkar avatar
Prasenjit Sarkar@stretchcloud·16h

Your coding agent can finally boot a real Mac instead of a Linux box pretending to be one. Daytona put macOS sandboxes live on M4, M4 Pro and M5 Pro silicon this week, and the number that actually matters here is the boot time, not the chip: about 60 milliseconds, because Daytona pre-distributes machine snapshots onto the drives sitting next to the compute instead of booting from scratch. A hyperscaler VM takes anywhere from 30 seconds to several minutes for the same job. Two weeks ago Daytona crossed $100M in run rate, up 37.5x this year, not long after a hard pivot where they handed old customers to competitors and rebuilt with only a few months of runway left. They also just closed a $60M Series B at a $1B valuation, FirstMark leading, with Patrick Collison, Tobi Lutke, Aravind Srinivas and Eric Yuan writing personal checks. Anthropic, OpenAI, Nvidia, Cursor and Cognition are already customers. Nobody builds that curve selling ordinary VMs. The category around it is filling in fast and the pricing has already converged: E2B, Blaxel and Daytona all land near the same cost per second of active compute. What's actually different is idle handling. Blaxel bills nothing once a sandbox goes to standby. E2B keeps billing until you pause it yourself. Daytona's bet is that the agent, not the human, decides when the machine disappears. The part nobody's pricing in is what Mac support actually unlocks. iOS and macOS builds have been the one corner of software agents couldn't touch, because you need real Apple silicon and Apple doesn't rent it out at scale. My guess is this ends up mattering more than the funding number: it's the first real opening into a category of work that's been sitting outside the agent economy entirely. x.com/ivanburazin/status/212…

Post attachment
Prasenjit Sarkar avatar
Prasenjit Sarkar@stretchcloud·16h

"I built Kalvyr to see what my AI coding agents are changing, live, by component. Who's editing checkout? Which checks failed? What needs me?" That's one builder's answer to a problem almost nobody admits to having: once Claude and Codex are both touching the same codebase, you lose track of which agent did what, and you find out by reading a diff after the fact instead of watching it happen. That problem exists because nobody runs just one coding agent anymore. Terminal-Bench 2.1 has Codex CLI at 83.4 percent on GPT-5.5, Claude Code at 78.9 percent on Opus 4.8, Gemini CLI at 70.7 percent, and OpenCode out-stars all three on GitHub without requiring a single subscription. Different models win different tasks, so people run several on purpose, then have no shared view of what any of them actually did until something breaks. Visibility into tool calls is the part that's missing, not another dashboard for a single agent's own session. A changelog per agent doesn't help when the question is which agent caused the regression you're staring at right now. That's what Campfire tracks natively. Every tool call across every backend, Claude Code, Codex, Goose, Aider, OpenHands, lands on a kanban board built straight from the agents' own actions, not a status a human typed in after the fact. Agent races run the identical task against every backend at once in isolated git worktrees, so instead of trusting someone else's benchmark table you get your own, on your own codebase. A cost dashboard tracks spend per agent per task, and the Collective Intelligence layer keeps semantic memory shared across agents and sessions, so the next run doesn't start from zero just because a different backend is doing the work this time. github.com/stretchcloud/camp… x.com/SFKhadraoui/status/212…

0:34
Prasenjit Sarkar avatar
Prasenjit Sarkar@stretchcloud·17h

Four of the largest consumer platforms on earth now each have a button that lets an AI agent spend your money without you opening a second tab. Google's version went free this week for hundreds of millions of people across six countries: Tasks in Gemini, running on the new Gemini 4 Hydrogen model, reaching across Gmail, Calendar, Drive and more than sixty other apps, calling two businesses in parallel to book an appointment, then checking out through Google Pay under the Agent Payments Protocol once you've set a spending cap. It's racing three rivals that shipped the same basic idea within months of each other. Amazon discontinued Rufus, the assistant that reached 300 million shoppers, folding it into Alexa for Shopping: free for any signed-in account, no Prime or Echo required, with a Buy for Me feature that checks out on other retailers' sites using your saved card. OpenAI's Instant Checkout has been live in ChatGPT since September and already covers more than a million merchants through Shopify and Stripe. Microsoft announced Copilot Checkout at NRF, built on PayPal, Shopify and Stripe, auto-enrolling Shopify sellers unless they opt out. Similarweb has ChatGPT holding 68 percent of AI chatbot web traffic against Gemini's 18 percent and Copilot stuck in the single digits. Giving Tasks away for free isn't generosity, it's the cheapest lever Google has to close a usage gap that size before anyone's checkout habits set. Here's the part getting buried under the free-tier headlines: Amazon's Buy for Me already drew complaints from brands who say they were listed without consent and described inaccurately by the agent shopping on their behalf. Microsoft's opt-out model for Shopify sellers is picking up the same complaint before it's even finished rolling out. Four companies are racing to be first through checkout. Getting the catalog right was supposed to be the easy part.

Prasenjit Sarkar avatar
Prasenjit Sarkar@stretchcloud·17h

Add /sitemap.xml to any competitor's homepage and you get a public list of every page they've ever wanted Google to find. Sort by lastmod and you see exactly what they worked on this month. Scan for '/vs/' and '/alternative/' and you know who they're attacking. That trick is going around right now, and it only gets you URLs. It says nothing about what's actually sitting on any of those pages. Firecrawl just raised a $75M Series B, led by Smash Ventures with YC, Altos and Nexus in the round, to turn that kind of reconnaissance into something that runs continuously instead of once a month by hand. Their pricing shows what continuous actually costs: a basic one-credit page runs $3.20 per thousand pages on the entry Hobby tier, down to sixty cents at the top Scale tier, and JSON extraction multiplies that credit cost by five. Real money for real infrastructure, still bounded to whatever one scrape call hands back. A pricing table rendered in JavaScript, a PDF case study, a screenshot of a redesigned landing page, a page sitting three clicks behind a form: a sitemap tells you none of it exists until a human goes and looks. Checking that by hand across dozens of competitors every month is exactly the part nobody scales. That's the gap I built DeepScrape to close. Point it at a goal in plain language, find every page that mentions pricing, or screenshot their new homepage, and it navigates the site itself rather than stopping at the sitemap, pulling back markdown, full HTML, screenshots, tables and PDFs from whatever it finds, in one pass. Watching their /vs/ pages for anything new stops being a monthly chore and turns into a standing job an agent just runs. github.com/stretchcloud/deep… x.com/googlewaqas/status/212…