@stretchcloud: signal 73/100
Is this your account? Share your reading:
#3 of 190 accounts read, fewer needle hits than 99% of them. The leaderboard
Most of these 20 posts are about other people's work. With most of them about what @stretchcloud builds, measures or lives, this account joins Find, where people look for builders worth following. The next reading counts the newest posts.
Prasenjit Sarkar, the last 20 posts, read by six needles. A reading of the words, not a verdict on the person, and not a prediction of reach.
Every post, ranked
Best to weakest by overall signal. Pick a needle to rank the posts by that needle alone.
-
1 of 20 Strongest post
124views1likes0reposts0replies
A visual harness where agents show up as a crew, pick up tickets, and work after hours while you sleep. That is basically where multi agent coding orchestration has landed in 2026, and the tooling underneath it is moving fast enough that most people building products haven't caught up to what's available. The category split into tiers this year. Conductor clones your repo into isolated Mac workspaces for parallel Claude Code and Codex runs, but it is Mac only. Claude Squad gets you Claude Code, Codex, Aider, and OpenCode each in their own git worktree. Vibe Kanban, Gastown, and Kilo Code's Agent Manager all took a swing at the same problem from different angles, and in April 2026 Anthropic shipped Claude Code Agent Teams while OpenAI answered with parallel cloud sandboxes for Codex. Everyone agrees the future is several agents working at once. Almost nobody agrees on how you supervise them, or what happens when they disagree. That governance gap is the part I don't see solved elsewhere. I built Campfire to run Claude Code, Codex, Goose, Aider, and OpenHands side by side in one browser tab, with permission voting across the crew: majority rules approves an action, any single deny blocks it, and a 30 second timer keeps things from stalling. Session replay lets you see exactly what an agent did and why. Agent races run the same task across every backend in isolated git worktrees, so choosing a backend stops being a guess and becomes a comparison you can actually see. Forking and branching use that same worktree isolation. There's a cost dashboard, a Monaco editor, an embedded terminal, a side by side diff viewer, and a kanban board built straight from the agents' own tool calls instead of something you maintain by hand. Install is one line: bunx the-campfire.
This post carries a quoted post. The needles only read the words, so it is left out of the account's score.
signalVague1%Nothing new23%Secondhand6%Nothing to use10%Bait or brag27%Hype43% -
2 of 20 230views1likes0reposts1replies
Adonias just posted something that is becoming a normal Tuesday for anyone running coding agents seriously: Opus 5.5 built a full CRM from one prompt by delegating to 6 subagents, one building the foundation while five others worked two parallel waves, pulling real UI patterns from a design MCP and running screenshot review loops on every page. Four hours, one human review pass at the end. What that anecdote does not show is what happens once you are not the only one watching. The research on this is consistent: multi-agent coding setups burn roughly 15 times the tokens of a single chat session, and the bottleneck people report after the delegation works is not agent capability anymore, it is keeping track of six agents making decisions at once. Supervision fatigue is a real term researchers and practitioners are both using now, not a joke. I built Campfire because that supervision problem does not go away by using a better model, it goes away by having infrastructure built for watching multiple agents instead of one. Campfire runs Claude Code, Codex, Goose, Aider, and OpenHands side by side in a single browser tab, each in its own git worktree so parallel waves like Adonias described do not step on each other. Permission voting means a risky action needs majority approval or any single deny blocks it, with a 30 second timer so you are not the only one gating every file write across six agents. Agent races let you run the same task across backends in isolated worktrees and compare output before you commit to one. A cost dashboard and a kanban board built directly from agent tool calls give you the observability layer that one review from me at the end quietly depends on actually working past two or three agents. The pattern from Adonias's build is the future. The tooling to supervise it at more than hobby scale is still mostly missing, and that is the gap Campfire is built to close.
This post carries a quoted post. The needles only read the words, so it is left out of the account's score.
signalVague1%Nothing new27%Secondhand8%Nothing to use10%Bait or brag38%Hype38% -
3 of 20 172views1likes0reposts2replies
The way people are running coding agents changed under us in the last two weeks and most of the discourse has not caught up. The old pattern was one chat thread per task. The new one, which Cursor just shipped as Projects, is a persistent coordinator agent that manages subagents across many projects at once. I watched someone describe running 10 projects in parallel this week: performance work, tech debt cleanup, a Rust experiment, user feedback fixes, new dashboards, a game, all supervised rather than hand typed one task at a time. Cognition is seeing the same shift from the enterprise side, Devin just crossed a billion dollars in annualized revenue run rate, and their customers describe the same pattern, agents running continuously across many workstreams rather than one prompt at a time. The problem nobody solves by adding more agents is coordination. Once you have five or ten agents running against the same codebase, you need to decide who approves what, you need a way to compare two agents attacking the same problem, and you need memory that survives past a single session so agents are not relearning your codebase every morning. That is what I built Campfire for. It runs Claude Code, Codex, Goose, Aider, OpenHands, and others side by side in one browser tab, each in its own git worktree so nothing collides. Permission voting means a risky action needs majority approval or dies to any single deny within a 30 second window, instead of one agent holding root on your repo unsupervised. Agent races let you run the same task across backends in isolated worktrees and diff the results before merging anything. Session replay and a cost dashboard mean you can see what every agent actually did and what it actually cost, not just trust the summary it gives you. A collective intelligence layer keeps semantic memory and shared context across agents so the tenth project does not start from zero context like the first one did. Parallel agents were never the hard part. Knowing which one to trust, and what it actually did, was always the real work.
This post carries a quoted post. The needles only read the words, so it is left out of the account's score.
signalVague1%Nothing new30%Secondhand6%Nothing to use11%Bait or brag35%Hype25% -
4 of 20 373views6likes0reposts7replies
Wait, this is what caught my eye too: Block just open sourced Buzz, a Slack-style workspace where humans and AI agents are full members with their own keys and their own audit trail, not bots bolted onto channels. It runs on the open Agent Client Protocol and already supports Claude Code, Codex, and Block's own goose framework side by side in the same room. The pattern I keep seeing across the category is that chat apps were never built for agents to be first class participants. You can bolt a bot into Slack, but it has no real identity, no signed history, and no way to hold state across a long running task. Buzz fixes that at the protocol level: every message, reaction, workflow step, code patch, and approval becomes a signed event in one relay log that you can self host. That's the exact problem I built Campfire to solve on the coding agent side specifically. Campfire runs Claude Code, Codex, Goose, Aider, and OpenHands side by side in one browser tab, with permission voting so a majority of agents or humans has to approve before anything risky executes, a 30 second timer on any pending decision, and full session replay so you can see exactly what every agent did and why. Git worktree isolation means you can fork a task and race the same prompt across every backend at once, then keep whichever result actually worked. Where Buzz gives agents equal standing in a workspace, Campfire gives them equal standing in a codebase: a Kanban board built automatically from tool calls, a cost dashboard so you know what each agent run actually cost, and a Collective Intelligence layer for shared memory across sessions so agents stop re-learning the same context every run. If Block is right that agents deserve real membership instead of bot status, the same logic applies to whichever agent is actually writing your code.
This post carries a quoted post. The needles only read the words, so it is left out of the account's score.
signalVague1%Nothing new26%Secondhand9%Nothing to use15%Bait or brag40%Hype22% -
5 of 20 253views3likes0reposts3replies
The prospect research workflow that is spreading right now says something true about where LLM cost actually goes. The pattern is simple: point Firecrawl at a prospect's site, crawl it, pull structured findings, and hand the LLM only the extracted facts to draft a pitch. That split matters more than it looks. The expensive part of most scraping pipelines was never the crawl, it was making a language model re-read the entire page on every single run just to find the same three data points it found yesterday. I built DeepScrape around removing exactly that tax. It generates a CSS selector once with an LLM, then reuses that deterministic selector on every future pass, no model call required, and only re-invokes the LLM when the page structure actually changes and the selector needs to self heal. The LLM's job shrinks to what it is actually good at: generating, validating, and adapting a selector, not reading raw HTML over and over to extract the same fields. The category is getting crowded for a reason. Firecrawl turns pages into LLM ready markdown and has become the default reach for teams doing exactly this kind of research. Apify and Diffbot cover the enterprise end with managed crawling infrastructure and structured extraction APIs. Browserless and ScrapingBee sell raw browser automation and proxy rotation without an extraction layer on top. What is mostly missing across that list is a deterministic memory of what worked last time, so every run pays LLM tokens again for the same page. DeepScrape also ships an MCP server, so Claude or Cursor can call scrapers directly as tools, and a site to MCP path that turns any website into a structured data source an agent can query on demand instead of re-scraping blind. Multi format output covers markdown, HTML, screenshots, PDF, tables, and change tracking, and /api/map handles URL discovery before extraction even starts. This is the same lesson every data pipeline relearns eventually: cache the expensive part, and only pay for intelligence where the page actually changed.
This post carries a quoted post. The needles only read the words, so it is left out of the account's score.
signalVague2%Nothing new38%Secondhand6%Nothing to use6%Bait or brag27%Hype16% -
6 of 20 415views5likes0reposts7replies
Managing 10 or more AI agents in parallel does not remove work, it relocates it. The tweet I am quoting names the real problem well: it is not agent capability anymore, it is supervision fatigue. Constantly switching context between agents, reviewing what each one did, deciding what gets merged, and owning the outcome alone when something breaks. This is the exact gap I built Campfire to close. It runs Claude Code, Codex, Goose, Aider, OpenHands and other coding agent CLIs side by side in one browser tab instead of five terminal windows you keep alt tabbing between. Permission requests go through majority rules voting across the agents on a task, with a 30 second timer and any single deny blocking the action, so you are not the only one making the call on every risky step. Every session gets replayed, so reviewing what an agent did is not archaeology. You can fork a task across isolated git worktrees and run the same prompt against multiple backends at once to see which one actually gets it right, instead of guessing which CLI to trust today. A cost dashboard and a kanban board built from the agents' own tool calls turn the fatigue in that tweet into something you can actually see and manage. The accountability problem in the tweet does not go away, but at least you are not carrying it alone across five disconnected terminals with no shared memory between sessions.
This post carries a quoted post. The needles only read the words, so it is left out of the account's score.
signalVague2%Nothing new39%Secondhand10%Nothing to use12%Bait or brag33%Hype14% -
7 of 20 410views5likes0reposts6replies
Peter just published a number that should worry anyone treating AI generated test coverage as a quality signal. OpenClaw deleted around 400,000 lines of its own test code and coverage barely moved. Modern coding models write a test for every tiny change by habit, whether or not that test catches anything real, and nobody was pruning the backlog. This is not an isolated anecdote. Researchers publishing on agent authored test code this year found the same pattern from a different angle: coding agents are systematically over mocking, producing tests that pass reliably because they test the mock instead of the behavior, an oracle problem that inflates coverage numbers without inflating actual defect detection. Separately, teams tracking AI generated codebases are seeing code duplication run about 4x higher than hand written code, which means the test surface area agents are asked to cover is also artificially larger than it needs to be. The fix that worked for OpenClaw was not a linter or a coverage gate, it was a skill: a SKILL.md file Claude Code loads on demand that tells the agent to be ambitious about deletion, not just cleanup. Peter's own framing in the thread: telling an agent to clean up makes it stop too early, but telling it to remove 20 percent of the least useful tests while maintaining code coverage within 2 percent gives it a target it can actually optimize against. That is a prompting insight as much as a tooling one. Claude Code's skills ecosystem has grown fast enough that this is now a genre of its own. Officially maintained skill repositories are pulling six figure star counts, plugin marketplaces list several hundred skills, and audit skills exist now specifically to score other skills against a six dimension rubric for whether they actually close the loop instead of just running. Test auditing has become its own subcategory inside that, alongside frontend design skills and context engineering skills. I have seen this exact shape before in a different decade. Continuous integration in the 2010s went through the same phase, teams added tests until the suite itself became the maintenance burden, then somebody had to build tooling whose entire job was pruning tests nobody trusted anymore. The difference this time is the code and the tests were both written by the same non human author in the same afternoon, so the debt compounds faster and the reviewer has no memory of writing any of it. The bottleneck people are missing: coverage percentage was never the metric that mattered, and now that generating both code and tests costs nothing, that gap is finally visible instead of theoretical. My take, if your agent workflow does not have an explicit test pruning pass, you are paying CI minutes and review time for a metric that was already lying to you before agents showed up.
This post carries a quoted post. The needles only read the words, so it is left out of the account's score.
signalVague1%Nothing new22%Secondhand77%Nothing to use5%Bait or brag18%Hype22% -
8 of 20 406views2likes0reposts3replies
The harness tax is the number nobody was tracking. Researchers at Berkeley and Arena just published HarnessTax, running seven models through three coding agent harnesses, Claude Code, Codex CLI, and Pi, across 21 model harness pairs on SWE bench Lite and Terminal Bench 2.0. My read on the finding: harness choice barely moves task success rate, but it can move cost by up to 5x for the exact same model doing the exact same task. Pi, a minimal open source harness from earendil works, came in competitive on both cost and success rate against the heavier branded harnesses. Across the six Anthropic and OpenAI models tested, a non default harness produced the best success rate in nine of twelve comparisons. Provider optimized pairing, Claude models paired with Claude Code, OpenAI models paired with Codex CLI, does not automatically win. This lands the same week AWS open sourced Strands harness, an Apache 2.0 general purpose agent wrapper that claims 28 percent lower token cost than Claude Code and Codex at comparable accuracy, mostly by truncating large tool outputs and triggering context compaction before the window fills. Worth a healthy dose of skepticism since AWS is grading its own homework, but the direction matches HarnessTax: the scaffolding around a model is now a line item, not a rounding error. I have watched this exact pattern before with cloud compute. Nobody priced the orchestration layer separately until someone benchmarked it and found the convenience tax was 3 to 5x. Then FinOps became a job function. Coding agents are heading the same way: teams will start treating harness selection as a cost engineering decision, not a taste preference. The hidden bottleneck is that most teams pick a harness because it shipped from the same lab as their model, not because anyone measured it. HarnessTax is the first credible attempt to put a number on what that habit actually costs, and the number is bigger than most people's model choice ever was.
This post carries a quoted post. The needles only read the words, so it is left out of the account's score.
signalVague1%Nothing new22%Secondhand93%Nothing to use8%Bait or brag12%Hype24% -
9 of 20 373views2likes0reposts2replies
The bottleneck Nicolas is describing already has a name and a standards body behind it. He is asking who is building a peer to peer board for agents instead of having them fake being humans and send each other emails. That protocol exists now, it just took two years to get boring enough to matter. Google shipped Agent to Agent, A2A, and handed it to the Linux Foundation in 2026. It hit version 1.0 in April with signed Agent Cards, JSON-LD descriptors that let one agent discover what another agent can do, what it costs, and how to authenticate before sending it work. More than 50 organizations have deployed Agent Cards through the AAIF working group, which is the first cross vendor agent interoperability push I have seen actually ship instead of stay a whitepaper. IBM tried a competing standard, ACP, built on the old FIPA-ACL negotiation semantics from 1990s multi-agent research. IBM's own docs now tell people to migrate off it, it folded into A2A. Cisco is running a parallel track called AGNTCY with LangChain, LlamaIndex, Galileo, and Glean, focused on the Open Agent Schema Framework for identity and discovery rather than messaging itself. The stack that is actually forming: MCP for agent to tool, A2A for agent to agent delegation, AGNTCY for identity and discovery underneath both. Three different problems, three different layers, and vendors are finally not fighting to own all three at once. What Nicolas is running into in practice, agents DMing each other on Teams pretending to be colleagues, is the exact failure mode this stack is meant to kill. An agent asking another agent a question should look like a function call with a receipt, not a Slack thread. Every infrastructure shift I have watched, REST replacing SOAP, gRPC replacing REST for service to service calls, followed the same arc: humans build the fast synchronous thing once they get tired of pretending machines talk like people. The hidden bottleneck is not model quality anymore. It is that most companies still route agent coordination through interfaces built for humans, chat, email, tickets, because that is what was available. My read: teams that adopt A2A or an equivalent typed protocol for agent to agent work now save themselves a rebuild in twelve months when their multi agent systems stop being one team's side project.
This post carries a quoted post. The needles only read the words, so it is left out of the account's score.
signalVague1%Nothing new25%Secondhand91%Nothing to use10%Bait or brag17%Hype30% -
10 of 20 132views0likes0reposts0replies
The pattern I keep seeing this week: the biggest ad platforms are starting to hand their own APIs to their own agents, and pointing them at your account. Meta shipped this with Muse. Ahad Shams pointed it at his Meta ad account and what came back wasn't a dashboard, it was a WhatsApp message. Muse reads Meta's own ad platform through Meta's own MCP server. One OAuth tap and it reports spend, CPA, CTR deltas every morning, sweeps the Ad Library for competitor launches, flags frequency fatigue a week before ROAS drops, and asks before it pauses anything. The mechanism matters more than the demo. Meta is not building a new ad tool. It is exposing Ads Manager as an MCP server and letting a general agent sit on top of it. That is a different move than the last decade of ad tech. Widen the lens and the category is already crowded. built creative automation and media buying into one enterprise platform. Madgicx runs Meta-only autonomous agents for ad rotation and creative refresh on spend-tiered pricing. only generates creative, it does not touch campaigns. Pixis and Omneky sit somewhere in between. All of them built bespoke integrations against Meta's ad API. Muse skips that work because Meta owns both sides of the MCP connection. What I keep noticing is founders treating this as free labor rather than a product to buy. Muse is free for most of what a small account needs, with paid tiers at $20 and $100 a month for heavier use. That pricing undercuts every dedicated ad agent on the market before they even had a chance to compete on the open protocol. I have seen this exact pattern before. AWS did not need a separate monitoring company once CloudWatch shipped natively. Stripe did not need third party fraud tools once Radar was built in. When the platform owner ships the agent, the surrounding tool layer gets squeezed fast, no matter how good the standalone product is. The hidden bottleneck was never the AI. It was API access and trust. Meta already has both, on every ad account that already exists. My read: this is the first real proof that MCP servers turn a platform's own API surface into distribution. Whoever owns the API now owns the agent, and everyone building a wrapper on top of someone else's ads platform should be watching this a lot more closely than they're watching model releases.
This post carries a quoted post. The needles only read the words, so it is left out of the account's score.
signalVague1%Nothing new28%Secondhand87%Nothing to use13%Bait or brag13%Hype30% -
11 of 20 289views1likes0reposts2replies
The bottleneck in agent loops just got exposed, and it is not model intelligence. Every time an agent decides which button to click, which search result to trust, or which tool call to make next, most stacks still route that micro decision through a full language model. Generating text to answer a yes or no question is expensive and slow, and it adds up fast across a long agentic trajectory. Jev showed up first. TypeSafe AI, started by Diogo Almeida, a former OpenAI researcher who co-authored the 2022 paper that established RLHF as a training method, released it as a System One model built purely for scoring, classifying, and choosing rather than generating. TypeSafe claims Jev runs up to 194x faster and 445x cheaper than frontier models like GPT-6 Astra, with a median 0.35 seconds per passage check against 8.83 seconds for a high effort frontier model. Now Stanford and NVIDIA answered back. Researchers from Stanford's Scaling Intelligence Lab and Hazy Research, working with Jacky Kwok, released CLM, a Contrastive Language Model. CLM-8B runs on a frozen Qwen3-8B backbone with a 20M parameter trainable projection head, trained on 60M Nemotron Q&A pairs, 30M synthetic hard negatives, and a million agentic trajectories. Instead of generating an answer, it scores candidate actions against the current state through cosine similarity in a shared embedding space, like a zero shot classifier. State and action embeddings are computed separately, so they can be cached and reused, which is why CLM claims up to 9x faster than Jev at matching accuracy, and up to 13x faster once you are scoring around a thousand candidates. A multimodal CLM-35B is already training for an October release, and the project is open on GitHub, while Jev stays inside TypeSafe's product. I keep coming back to how familiar this shape is. Databases got a caching layer once query cost became the bottleneck. Search got vector retrieval once full re-ranking got too slow. Compute got a GPU once every workload stopped needing a general purpose CPU. Agent infrastructure is going through the same split right now: a slow, expensive reasoning layer for genuinely hard steps, and a fast, cheap, disposable layer for the thousands of small decisions in between. The part nobody prices in yet is trust. A classifier that is 9x faster only helps if its wrong answers fail safely, and most teams have not built guardrails for a model that was never designed to explain itself. My read is that the winner of this System One race will not be whoever is fastest on a benchmark, it will be whoever makes their failures cheap and legible.
This post carries a quoted post. The needles only read the words, so it is left out of the account's score.
signalVague1%Nothing new24%Secondhand96%Nothing to use10%Bait or brag11%Hype19% -
12 of 20 64views0likes0reposts0replies
The number in that benchmark that stopped me: 22 seconds versus 7 minutes 40 seconds for the same task, across the same class of AI assistant. My read is that inference speed just quietly became a product decision, not an infra footnote. The mechanism is simple. An agent doing real work is not one model call, it is a chain of them: plan, search, evaluate, act, verify, repeat. Each hop's latency compounds. A model that is twice as fast does not make the task twice as fast, it makes a ten step loop an order of magnitude faster, because the waiting was never in one place, it was smeared across every step. This is why the chip layer under the agent is becoming as important as the model on top of it. Cerebras runs Llama 3.3 70B at roughly 2,100 tokens per second on its wafer scale WSE-3, versus roughly 750 for Groq's LPU on the same model, though Groq undercuts on price at about $0.59 to $0.79 per million tokens versus $0.85 to $1.20 for Cerebras. SambaNova sits in the same speed tier as Groq on most published benchmarks. Three different bets on the same problem: Cerebras spends silicon on raw throughput, Groq spends architecture on cost per token, and both are now public companies. Cerebras IPO'd in May 2026, priced at $185, opened near $385, and closed its first day near a $66 billion valuation, up from an $8.1 billion mark just eight months earlier. The number that made that jump credible was the financials underneath it: revenue near $510 million and a swing from a nearly $500 million loss to $237.8 million in net profit. I keep coming back to a pattern from the DevOps era. The move from batch processing to real time systems did not just change what was possible, it changed who won: the companies that treated latency as a feature, not a metric, took the category. Inference speed for agents is following the same arc. The hidden bottleneck was never model intelligence, it was the twenty invisible round trips an agent makes before it ever tells you it is done. For anyone building agent products right now, my take is that the chip and inference provider you pick is no longer a backend decision your users never see. It is the difference between an agent that feels like a colleague and one that feels like a support ticket.
This post carries a quoted post. The needles only read the words, so it is left out of the account's score.
signalVague1%Nothing new33%Secondhand90%Nothing to use9%Bait or brag11%Hype25% -
13 of 20 347views4likes0reposts3replies
Yasser just published a number that would have been a rounding error eighteen months ago. Thirty seven percent of new signups at Chatbase now come from LLM recommendation, and those are the highest converting signups the company gets. The data backs him up at the category level. Semrush measured LLM referred traffic converting at roughly 4.4 times the rate of traditional organic search, and multiple trackers put ChatGPT, Perplexity, and Claude referral conversion in the 5 to 16 percent range against under 2 percent for regular organic. ChatGPT driven referral traffic grew 123 percent in about five months through early 2025, and it has kept compounding, it is now the largest single AI referral source for most sites that track it. A whole vendor category built around this in under two years. Profound raised a 96 million dollar Series C in February, sits at a 1 billion dollar valuation, backers include Kleiner Perkins, Sequoia, and Founders Fund. It sells enterprises visibility into how often their brand gets cited inside AI answers. AthenaHQ, the YC backed challenger, undercuts on price with a 295 dollar a month starter tier and a free tier, betting on volume instead of enterprise contracts. Both exist because marketing teams that used to obsess over Google's algorithm now need to know what ChatGPT and Perplexity say about them, and neither company controls that ranking the way SEO tools once modeled Google's. Yasser's own conclusion is the more interesting part: nothing beats building a good product and letting the world know about it. That is close to the opposite of classic SEO doctrine, where you could out backlink a worse product into the top slot. LLM answers today reward being genuinely recommendable in training and retrieval data, not being gamed. I keep coming back to the same historical comparison. Google search ranking created an entire SEO industry that spent two decades reverse engineering a black box. AEO is doing the same thing in a fraction of the time, except this black box changes its own ranking logic every time a new model ships. The bottleneck for growth teams right now is not traffic acquisition, it is not having any idea what ranking even means across five different chat interfaces at once. Whoever gets measurement right first owns the playbook for the next decade of growth marketing.
This post carries a quoted post. The needles only read the words, so it is left out of the account's score.
signalVague1%Nothing new24%Secondhand94%Nothing to use16%Bait or brag10%Hype30% -
14 of 20 181views3likes0reposts2replies
The pattern I keep seeing across coding agents this year: the bottleneck stopped being the model and became the map. Understand-Anything, a Claude Code plugin that turns a codebase into an explorable knowledge graph, is a small tool pointing at a real shift. The mechanism is worth spelling out. Plain retrieval, the RAG approach most agents still lean on, finds text that looks similar to your question. It does not know that function A calls function B, that B owns a database table, or that changing B breaks three other services. A graph keeps that structure: files, functions, classes, and the calls and dependencies between them, so an agent doing a multi file refactor can walk real relationships instead of guessing from embeddings. This is not one tool, it is a category forming in real time. Sourcegraph's Cody reads a repo through a code graph of indexed symbols and references, though its individual plans ended in July 2025 as the company leaned into enterprise. Augment built a Context Engine that indexes up to 500,000 files and feeds an autonomous agent inside the IDE. Greptile builds a semantic graph across repos for multi hop bug investigation during code review. Graphify parses code locally with tree-sitter into a typed graph of nodes and edges across 36 languages. Understand-Anything's angle is going cross agent: it works with Claude Code, Codex, Cursor, Copilot CLI, and Gemini CLI instead of locking you to one vendor's context layer. The adoption signal is the shift in what agentic coding even means now. Through 2026, the work moved from suggesting the next line to opening a pull request, running the tests, and opening the next one. That only works at repo scale if the agent has something better than a bigger context window, because token budgets do not scale linearly with codebase size no matter how large the window gets. I think about this the same way I think about the jump from grep to language servers a decade ago. LSP gave IDEs structural understanding of code instead of text matching, and every serious tool adopted it within a few years. Coding agents are having that same moment now, just compressed into months instead of years. The hidden bottleneck was never how much an agent could read, it was how cheaply it could figure out what actually mattered before it read anything. My take for anyone building in this space: the founders worth watching this cycle are not training bigger models, they are building the index layer the agent stands on.
This post carries a quoted post. The needles only read the words, so it is left out of the account's score.
signalVague1%Nothing new34%Secondhand92%Nothing to use10%Bait or brag12%Hype25% -
15 of 20 65views0likes0reposts0replies
Marc Benioff said it's not the end of software. My read on why that statement needed making at all: the argument that software is ending has gotten loud enough that the company that sells the most enterprise software felt the need to respond to it in public. The pattern I keep seeing across the category is more precise than "software is dying." It's that software stopped making humans do all the work. For decades we went to software, opened an app, clicked through a UI someone designed months ago. Now the interface gets generated per task, on the fly, while a human stays in the loop to approve and steer. CopilotKit is building the plumbing for that shift. They raised a $27M Series A led by Glilot Capital, NFX, and SignalFire, with Discovery Ventures, Vermilion Cliffs, DVC, and others in the round. Their protocol, AG-UI, standardizes how agents stream responses, generate interactive components, share app state, and call frontend tools in real time. It's already adopted by Google, Microsoft, Amazon, and Oracle, plus frameworks like LangChain, Mastra, PydanticAI, and Agno. Customers include DocuSign, S&P Global, Cisco, and Deutsche Telekom. They aren't alone. Vercel's AI SDK ships its own generative UI primitives. Thesys and Crayon are both building UI-generation layers aimed at the same problem: an agent that needs to draw a chart, a form, or a checkout flow that didn't exist as a component five seconds ago. Salesforce's own answer is Agentforce, which is presumably what prompted Benioff's comment in the first place. What I keep noticing is that none of these companies are trying to lock the interface layer to one vendor. AG-UI is explicitly open, the same way MCP was open when Anthropic shipped it. Protocols win adoption races that products lose. I watched the same fight happen with APIs and REST, then again with Kubernetes and container orchestration. The company that opens the standard early usually ends up owning the layer underneath everyone else's product, including competitors who never intended to build on top of it. The hidden bottleneck here isn't model quality, every frontier model can already reason about what UI to show. It's that most apps have no runtime that can safely accept an agent-drawn interface and reconcile it with existing state. That's the actual product CopilotKit and Thesys are selling. My synthesis: SaaS isn't dying, but the fixed, hand-designed interface on top of it is. The founders worth watching are the ones building the runtime underneath the interface, not the ones building another chatbot on top of it.
This post carries a quoted post. The needles only read the words, so it is left out of the account's score.
signalVague1%Nothing new29%Secondhand95%Nothing to use13%Bait or brag12%Hype30% -
16 of 20 107views0likes0reposts0replies
The number that got me: Zach Yadegari says Persona is already a 9 figure company, months after selling Cal AI to MyFitnessPal and only ten days after opening preorders. That's not app revenue, that's preorders for a $179 aluminum wristband that hasn't shipped yet. The mechanism is worth sitting with because the hardware category it's entering has mostly failed. Humane's AI Pin got discontinued and sold to HP for $116 million, a fraction of its $1 billion valuation, after return rates exceeded new sales. Friend spent over a million dollars on subway ads for a pendant that hadn't shipped and got mocked for it. Rabbit R1 survived by continuously shipping software fixes rather than nailing the hardware on day one. The common failure mode: asking people to learn an unfamiliar interaction model and trust an unready AI, all at once, with a device that tries to replace a phone. Persona's bet is narrower. No screen, no attempt to run apps, just two microphones, a speaker, and an LED ring acting as a remote control for an assistant that lives in the cloud and a companion phone app. Yadegari's own framing, that "others couldn't figure out the interface," is a direct shot at exactly that graveyard of failed devices. Widen the lens and Meta just validated the category from the other direction: it acquired Limitless, the conversation recording pendant, in December and folded it into its own wearable AI push, pulling it from sale to new customers in the process. So the two live approaches right now are Meta building AI hardware into glasses people already wear, and independent founders like Yadegari betting on a narrow, single purpose wearable that does one thing well. What I keep noticing is that Yadegari is running the same playbook twice. Cal AI wasn't the first calorie tracking app, it won by being radically simpler than MyFitnessPal's own product until MyFitnessPal just bought the simpler version. Persona isn't the first AI wearable, it's betting that simpler beats feature complete again. I've seen this pattern before in consumer hardware generally: the second wave of a category always ships narrower than the first. Fitbit shipped a screen and apps, the second wave of trackers stripped both out and just measured sleep. Wearable AI looks headed the same direction, from do everything device to single purpose remote control. My take: the interface war in AI hardware isn't about the model anymore, every one of these devices runs similar frontier models under the hood. It's entirely about how much you ask the user to learn before the thing feels invisible. Whoever gets closest to zero wins the category.
This post carries a quoted post. The needles only read the words, so it is left out of the account's score.
signalVague1%Nothing new34%Secondhand96%Nothing to use10%Bait or brag10%Hype15% -
17 of 20 474views3likes0reposts1replies
The number that stopped me this week: OpenAI's next ChatGPT tier is reportedly $500 a month, nearly double what any AI subscription commands from consumers today. That number only makes sense once you connect it to the other half of the leak, that the fast path is being built on Cerebras silicon instead of Nvidia GPUs. The mechanism is speed as the product, not intelligence as the product. OpenAI already runs GPT-5.6 Sol Ultrafast on Cerebras for its latency sensitive path. Cerebras' wafer scale chips push inference throughput that Nvidia's GPU clusters cannot match on tokens per second for a single request, even if Nvidia still wins on raw training throughput and cost per token at scale. Pro Max is reportedly scoped around "Fastest Work and Codex," which reads like OpenAI is finally willing to charge separately for latency instead of bundling it in. Widen the lens and this is a live infrastructure fight. Cerebras also powers parts of Mistral's Le Chat and has direct deals with G42 and others chasing sub-second inference. Groq is running the same playbook with its LPU architecture, already integrated into products like Bell Canada's assistant and several coding tools that need fast autocomplete. Fireworks and Together AI both sell speed as a line item on their own hosted inference, separate from the base model price. Every one of these companies is making the same bet: once agents do multi step work instead of single replies, latency compounds across every tool call, and someone will pay a premium to remove it. What I keep noticing in the developer threads is less excitement about capability and more math about whether five Claude Max seats beat one $500 seat that still can't do UI work as well. That's a pricing objection, not a capability one, and it tells you the market is already treating raw speed as a separate SKU from raw intelligence. I've watched this exact split happen before, in databases. Postgres got you correctness, then a whole industry got built selling you speed on top of the same data: Redis for cache, ClickHouse for analytics, connection poolers for concurrency. Inference is splitting the same way, base model versus fast lane, and the fast lane is where the margin lives. The hidden bottleneck isn't compute anymore, it's whether your workflow actually needs sub-second responses enough to pay for it. Most agentic coding work doesn't, most consumer chat doesn't either. The buyers who need it are running many parallel agent calls where latency multiplies. My take: watch Cerebras' customer list more closely than you watch OpenAI's price page. Whoever they sign next tells you which category is about to get its own speed tier.
This post carries a quoted post. The needles only read the words, so it is left out of the account's score.
signalVague1%Nothing new35%Secondhand93%Nothing to use12%Bait or brag11%Hype20% -
18 of 20 304views2likes0reposts2replies
The bottleneck moved again. For two years the agent conversation was about which model is smartest. Now it is about what happens after the model decides to act: who keeps that agent alive, isolated, and paying for itself while it works. Google just open sourced ax, a declarative orchestration runtime built to run agent workloads at cluster scale, and it is kubectl shaped on purpose. Apply a spec, get status, watch, describe, delete, the same verbs anyone who has run Kubernetes already knows. The reason it exists is that agents do not fit the two boxes cloud infrastructure was built around. They are not stateless microservices that can be killed and restarted for free. They are not batch jobs that run to completion and disappear. An agent accumulates state across a long session, needs strict sandboxing because it is calling tools and executing code, and can quietly burn real money in a loop if nobody is watching the meter. Traditional orchestrators either keep an idle sandbox running at cost, or they lack the sub second suspend and resume an agent fleet actually needs. This is not a solo bet. Modal closed a 355 million dollar Series C in May at a 4.65 billion valuation for GPU sandboxed execution. Daytona raised a 24 million Series A in February after repositioning entirely around sub 90 millisecond cold start agent sandboxes. E2B has pushed past a billion sandboxes run on a much smaller balance sheet. AWS shipped its own answer three weeks ago with Strands harness, an open source agent wrapper that claims 28 percent lower token cost at comparable accuracy by truncating tool output and triggering compaction before the context window fills. Different layer of the stack, same instinct: agents are expensive to babysit, so build infrastructure that watches them instead of a person. I keep coming back to the early Kubernetes years. Every infrastructure shift starts with people hand rolling the orchestration themselves, in scripts and cron jobs and heroics, until someone builds the control plane and the hand rolled version becomes technical debt overnight. Agent infrastructure is at that point now. Teams running ten or more agents in parallel are discovering supervision fatigue is a real cost center, not a minor annoyance. The hidden bottleneck was never model quality. It is who owns the lifecycle of a running agent: who suspends it, resumes it, checks its spend, and decides what merges. Google publishing that as an open spec instead of a walled platform is the more interesting signal than the tool itself.
This post carries a quoted post. The needles only read the words, so it is left out of the account's score.
signalVague1%Nothing new30%Secondhand93%Nothing to use17%Bait or brag10%Hype17% -
19 of 20 84views0likes0reposts0replies
Anthropic is about to kill a UX pattern that shipped less than a year ago. Thariq posted that the Claude Code team is thinking about removing plan mode entirely and folding it into the shift+tab hotkey that already cycles effort levels. His stated reason: the models do not need a separate planning phase anymore, they can just decide how hard to think. The follow up matters more than the original post. After feedback, the actual plan is to turn plan mode into a built in mod and let mods override shift+tab or add entirely new modes. That is a small sentence with a big implication: Claude Code is moving toward a plugin architecture for its own core UX, not just for tools. Zoom out and this is not an isolated decision. Cursor shipped Projects this month, replacing per task chats with one persistent thread where a coordinator agent plans work and hands it to subagents that do the actual coding in parallel, mostly in the cloud. The coordinator never writes code itself, so it stays responsive while dispatching. Claude Code's own subagent model does something adjacent: a lead agent assigns subtasks and merges results from specialized agents with scoped tool access. Different vendors, same conclusion, arriving in the same month: a single agent thinking out loud in one mode is not how the next generation of coding agents will work. I have seen this exact convergence before in developer tools. Once separate vendors independently rebuild the same abstraction within weeks of each other, that abstraction is not a feature anymore, it is becoming the interface. Planning as a distinct step, coordinator plus workers as the execution model. The hidden bottleneck is that plan mode was always a workaround for models that could not reliably self assess effort. If that workaround is going away, the actual interface question becomes who defines the modes: the vendor, or the mod author. Anthropic just told us which one they are betting on.
This post carries a quoted post. The needles only read the words, so it is left out of the account's score.
signalVague2%Nothing new28%Secondhand93%Nothing to use19%Bait or brag11%Hype36% -
20 of 20 Weakest post
115views0likes0reposts1replies
Nadella just said the quiet part out loud: Copilot is not a chat feature anymore, it is trying to become the operating system employees work inside all day. The rebuild ships three pieces. Home merges Chat and Cowork with Office built directly in, so Word, Excel, and PowerPoint sit inside the same surface as the assistant. Code lets anyone build and run their own tools, powered by the same engine as GitHub Copilot. Autopilot, previously known internally as Scout, is the part that matters most: a persistent, proactive agent with its own identity and memory that keeps working when you are not looking at the screen. It enters private preview at the end of this month. This is not happening in isolation. Five major platforms launched enterprise agent products within roughly the same week back in April. Salesforce built Agentforce directly into its data model, strong for customer facing automation but it gets friction the moment a workflow leaves Salesforce. Google is running Agentspace across Gmail, Calendar, Drive, and Sheets, plus third party connectors. Glean sits on top of all of it as a search and retrieval layer across Slack, Notion, Confluence, and Jira for companies that refuse to standardize on one suite. Microsoft's bet is different from all of them: own identity, governance, orchestration, and the productivity surface at the same time, so the agent is not bolted onto the suite, it is the suite. I have seen this shape before. It is the same move Microsoft made with Office 365 against Google Docs, bundling everything into one subscription until switching cost became the real moat, not the individual features. It is also the same move that made Windows durable for two decades: not the best desktop experience feature by feature, but the one surface that already had your identity, your files, and your habits. The part nobody is pricing correctly is what happens once the agent has its own persistent identity and memory and acts while you are away from your desk. Capability was never the bottleneck here. Governance over an agent that remembers, initiates, and touches production systems without a human in the loop at the moment of action is the actual unsolved problem, and it is the one Microsoft is now shipping into private preview first and figuring out in public.
This post carries a quoted post. The needles only read the words, so it is left out of the account's score.
signalVague1%Nothing new35%Secondhand94%Nothing to use16%Bait or brag9%Hype26%
Read on 2026-09-25. This is your account and you want it gone? Write to hello@postneedle.com. The leaderboard