Unreal Agent
Daily briefing: The first new cat species described by science in a century
Nature, Published online: 21 September 2026; doi:10.1038/d41586-026-03008-z
Leopardus tilcayo is smaller than a housecat and covered in leopard-like spots. Plus, the brain might spawn from two types of precursor cell and how to maintain the foundations of human flourishing in a climate crisis.
Event-Based Early Warning of Vineyard Disease Risk from Environmental Time Series
SPINE: Bridging the Cyber-Physical Gap with Agentic AI
AgentHazard: A Benchmark for Evaluating Harmful Behavior in Computer-Use Agents
Rachel: A general-purpose language model directs and revises retrosynthetic routes
CliffCompaction: Cost-Efficient Compaction for Long-Horizon Coding Agents
The backwards AI pacing debate and how far business is from the frontier
Washington and Silicon Valley have found a new fight to pick over artificial intelligence in “pacing,” or the deliberate throttling of frontier model development until safety, alignment, and society at large can catch up. To its detractors, pacing is unilateral disarmament in the race with China. To its champions, pacing is the only responsible path for a technology whose own creators warn of catastrophic risk.
Both camps have fallen prey to the “Compute-to-GDP Fallacy”—the mistaken belief that every incremental leap in AI model performance immediately translates into macroeconomic output. Every prior general-purpose technology took decades to diffuse into measurable productivity. AI is following the same curve at an accelerated pace, but everyone seems to buy the hype that the laws of history or of economics do not apply this time.
In reality, Corporate America is already years behind the AI frontier, and the labs’ commercial fortunes will be decided by trust and adoption, not raw capability. Pacing would cost the economy remarkably little. Here’s why we—whether out of arrogance or misdiagnosis—are simply having the wrong argument.
The pacing skeptics’ suspicions are not frivolous. Is pacing real, or a savvy marketing gambit by frontier labs and cybersecurity companies polishing their financials ahead of IPOs? Would pacing cede the U.S. lead in AI to China, or would Beijing reciprocate and pace in its own manner?
The Frontier Problem
AI has plainly reached a critical capability milestone. Warnings of catastrophic or existential risk can no longer be dismissed outright, even if the near-term probability remains modest. Yet by focusing almost exclusively on cutting-edge models, frontier labs have mismanaged both their messaging and the public trust. More than 100 recent conversations with CEOs, policy leaders, and AI scientists for our coming book, When Machines Act, have convinced us that the pacing debate has lost sight of first-principles thinking.
Lost in the noise is the distinction between the cutting-edge research the labs conduct behind closed doors and the products they release to the public. The real question may be whether the labs need to slow down at all or simply do a better job of ensuring their products are safe for consumption.
The Alignment Problem
Since the release of ChatGPT in 2022, corporate leadership has scrambled with a speed unmatched in modern commercial history. Even so, while executive suites have mobilized with unprecedented urgency, the structural physics of enterprise architecture—fragmented data silos, legacy ERPs, strict compliance regimes, and basic data hygiene—make true economic absorption an inherently slow slog. As corporate budget shocks from runaway “tokenmaxxing” demonstrated, many daily enterprise workflows require far simpler models, and precious few tasks at the average Fortune 500 company demand a frontier system at all. Pacing, therefore, will neither harm economic output nor choke off the labs’ commercial revenues, because enterprises need time simply to assimilate the capabilities already on the table.
Among high-performing companies, more than two-thirds identify data as the primary barrier to implementing AI, a figure that has proven stubborn even as the models themselves have leaped forward. Only 7% describe their data as “completely ready” for AI; fewer than a quarter have a data strategy at all; and 63% either lack AI-suitable data management or are unsure whether they have it.
The Fallacy Problem
As McKinsey Senior Partner Asutosh Padhi emphasized on air with Fareed Zakaria, technical availability is fundamentally different from economic transformation. General-purpose technologies have historically required decades to reorganize workflows and generate broad-based productivity gains. Electricity took 75 years to lift productivity economy-wide. Computers required 50 years, and the Internet and mobile devices demanded 25. The underlying models may be ready, but the systemic organizational restructuring they demand will take substantial time. When McKinsey surveyed the business community, the firm found that only 6 percent of companies reported a “significant” impact and modest earnings attribution.
Companies are concentrating on the high-reward, low-risk automation tasks that models one or two generations old can already solve. As one highly respected former Wall Street CEO told us, these systems will run in parallel with legacy systems for years to confirm they operate correctly and that no regulatory risk is unknowingly absorbed.
Despite advances in frontier labs, corporate America will set the pace itself, ensuring a secure rollout regardless of what the labs decide. No company in any industry should release a product it believes to be dangerous, and AI is no exception.
A parallel dynamic has emerged in the economics of silicon. Older-generation chips, initially cast aside in the scramble for cutting-edge accelerators, are finding a second life as workhorses for the practical inference tasks that dominate enterprise demand. As Growth Protocol founder and CEO Miro Dimitrov noted at last week’s Yale CEO Caucus, deploying neuro-symbolic architectures has allowed his enterprise reasoning platform to slash inference costs by roughly 80-fold in live client deployments, largely by shifting workloads off ultra-expensive GPUs and onto everyday enterprise CPUs.
The Three Phases of AI Adoption
Corporate AI adoption is best understood in three phases, distinguished by how much work a company can responsibly hand over, which is gated by data readiness and the trust systems have earned. The first phase, assistance, consists of off-the-shelf copilots that ride atop enterprise platforms
What can you build with Jev
Hi folks,
Do you remember the site I one-shot with all the ‘forgotten devices’ of the past? Things like the tamogotchi, furby, walkman, og playstation, etc. Well I finally did something with it.
I always see people building cool interactions or experiences and just send them to my agent to link up with an idea or something I want to explore. Remixing and reverse engineering is a great way to play with things for the sake of it.
I also built my token activity tracker which shows which agent apps and models I use daily. It’s got a copyable prompt on the site, so your agent can do the same.
Everyone’s talking about Jev - I’m too overwhelmed with what everyone else is building with it that I’ve not used it for anything properly yet.
Headlines
Jev is now open to everyone. We covered the launch in the last post, but since then people are finding all sorts of uses for it. It’s different from usual LLMs. It is for builders, built to be used inside a tool.
You give it some text and ask questions: is this an ad (yes/no answers), which folder does this belong in (select between choices), how relevant is this result (score something)?
I quickly built a collection of things people are building with it and a short explainer: What is Jev? Some worth highlighting are:
An extension to skip sponsor segments on YouTube.
Filtering negative comments out of a chat in real time.
Search Gmail by intent, or filter your to-dos.
A new & smarter copy-paste, drag-and-drop and Cmd+F experience.
Controlling your Mac with Voice.
Naturally, a fair share of demos are trying to integrate Jev with modern coding agents. For example, using it for instant compaction. It looks cool, but it’s a terrible idea. It loses the cost savings from prompt caching.
Sidenote: experiments with compaction/dropping tool calls are often a loss these days. Codex’s implementation of compaction is so clean (and good) that the pain to build a custom setup is not worth the tiny gain you can squeeze out for a couple weeks.
— Keshav
Coding agents are also on the mind of TypeSafe’s CEO - he wrote down his thoughts here.
Projects in Claude Code are now a single master chat (instead of a folder) where you can dump your requirements, thoughts, tasks and let Claude spawn new threads to carry out the work you give it. These threads run as cloud sessions, but local support is coming. This new change is in beta and will be live for all users soon.
Also, finally, Claude Code will now support AGENTS.md (via their new feature Claude Mods).
Muse, Meta’s personal AI agent, is getting love from everyone (who has access). It has a Mac app and a developer platform to build connectors, so people can use external services through Muse. And of course, it’s heavily inspired by OpenClaw.
Muse can shop for you - well, it could, until Amazon started blocking it. Meta is working on it, with partnerships like this one with Shopify.
Grok 4.7 is out. It’s a questionable upgrade from Grok 4.6 - It performs better than GPT-5.6-Sol and Opus 5 on benchmarks, but takes a lot more tokens to do that, which takes away from its cost efficiency. I tried it and think it’s 💩. I was excited for it, as Grok 4.6 was pretty good for me in Pi, although I rarely chose it.
Building a voice agent? Agent STT by Speechmatics is powered by Linden, a new speech-to-text model purpose-built for voice agents. $0.30/hour ($0.15 after discounts), 25% cheaper than Deepgram Flux. Try it through Pipecat or LiveKit, or directly via Speechmatics’ API. Claim $100 credit.*
My feed
OpenAI formed an independent group of mathematicians to help them share the proofs and discoveries their agents are making.
Test your agent in simulations with Raindrop. (They raised a Series A recently)
Turning your best X posts into an automated blog and newsletter.
How to ship 2,500 PRs to production in a month.
A free, open-source Photoshop-like image editor.
A look inside Instinct’s memory, reverse-engineered.
A transcription model from SpaceX AI - Grok Voice Transcribe 2.0.
How to build a restrained software factory.
Powermove - a video editor you can change by talking to a coding agent.
MCP vs CLI for LLMs - are we debating the wrong thing?
Factory is now available in Slack Code.
On July 25,
Build a Speaker-Recognition App with Claude Code
Learn how to effectively code up an internal tool using Claude code or Codex
The post Build a Speaker-Recognition App with Claude Code appeared first on Towards Data Science.
NVIDIA Introduces SoL-Pi: Auto-Research Loops That Cut Coding Agent Token Traffic by Up to 49%
Coding agents now run for hours, not minutes. Every edit, test run and log read goes back into the model’s context. A team of researchers from NVIDIA, NTU and MIT have released SoL-Pi, a set of 4 efficiency mechanisms for the open-source Pi coding agent. An AI found these mechanisms by running auto-research loops at the harness layer. On the 51-task EdgeBench evaluation, SoL-Pi cuts recorded token traffic by 44.7% to 49.0% versus Pi and cuts API cost by roughly 33%. Its scores stay close to Pi on both GPT-5.6 Sol and Opus 5.
Is it deployable? Yes. SoL-Pi ships on GitHub under NVlabs as an MIT-licensed extension that runs on an unmodified Pi release. It is tested with Pi 0.85.1 and Node.js 22.19 or newer.
Why Target the Harness
Most efficiency work lowers the cost per token through faster kernels, quantization or cheaper models. SoL-Pi instead reduces how many tokens a task consumes. The harness is the layer that handles tool calls, context, observations and delegation.
Tuning a harness by hand is slow, and its parts are coupled: a fix in one place can push cost into later steps. Meta-Harness and similar systems automate this work. However, a recent study found that evolved harnesses can overfit their search tasks and give only marginal gains on unseen ones.
How the Search Works
A research AI observes execution traces from a separate agent running base Pi. It then proposes harness changes and tests them. The search covered:
- 152 proposed directions across 6 families: context, progress, tools, delegation, prompt and policy, and improvement and evaluation
- 535 executable environments: 495 built from GitHub issue-pull request pairs and 40 synthetic tasks with executable verifiers
- More than 3,000 runs and 60,000+ agent-environment interactions
Each search is a disposable, isolated loop. It follows the autoresearch cycle, extended with a Ralph Loop implementation step and an independent reviewer.
Acceptance rules are fixed before the search starts, and the optimizer cannot change them. Every capability metric must stay within a predeclared tolerance. The candidate must also improve at least 1 efficiency metric. EdgeBench stays held out. Of its 51 public tasks, 11 are used for one-way acceptance of frozen candidates and 40 for final evaluation. Held-out results never feed back into the search.
The 4 Mechanisms That Survived
- Action Fusion: Base Pi often edits a file and then issues a separate command to test, build or run it. Action Fusion merges both into 1 tool request and returns both outcomes in 1 observation. This removes a model round trip.
- Online Context Compact: Plan steps are tracked through
update_plan. When a step completes, the harness estimates how many requests remain. It then compares the projected input savings with the extra cost of rewriting the prompt cache. It invokes Pi’s native compaction when this gate passes or when context nears the window limit. - ObservationPack: Tool outputs above 10 KiB are archived locally and sent in full for the next 2 provider requests. From the 3rd request onward, the model sees a stable handle, the original size and a short excerpt of head and tail lines. Exact pages stay retrievable through the handle.
- Evidence-Preserving Reducer: Build and test logs of at least 4 KiB go to a cheaper model, GPT-5.6 Luna at
high, which writes a compact receipt. A deterministic verifier checks the receipt’s schema, source hash, exit status, exact quotes and size. The harness falls back to the original log in 3 cases: verification fails, credentials are suspected, or the receipt is not smaller.
Results on EdgeBench
| Backend | Harness | Tokens (B) | API Cost | Avg. Score |
|---|---|---|---|---|
| GPT-5.6 Sol | Codex | 3.05 | $1,787 | 34.7 |
| GPT-5.6 Sol | Pi | 2.15 | $1,339 | 44.8 |
| GPT-5.6 Sol | SoL-Pi [Efficiency] | 1.10 | $894 | 42.0 |
| GPT-5.6 Sol | SoL-Pi [Performance] | 2.02 | $1,271 | 47.2 |
| Opus 5 | Claude Code | 2.00 | $2,535 | 43.7 |
| Opus 5 | Pi | 2.37 | $1,741 | 44.8 |
| Opus 5 | SoL-Pi [Efficiency] | 1.31 | $1,158 | 42.2 |
| Opus 5 | SoL-Pi [Performance] | 2.10 | $1,605 | 50.5 |
The full stack was built on GPT-5.6 Sol and moved to Opus 5 without further search. On Opus 5, it keeps 94.3% of Pi’s score while cutting token traffic by 44.7% and API cost by 33.5%. On GPT-5.6 Sol, it keeps 93.7% of Pi’s score with 49.0% fewer tokens and 33.2% lower cost.
The Performance point uses the best single mechanism for each backend: ObservationPack on GPT-5.6 Sol and Action Fusion on Opus 5. It lifts scores 5.3% and 12.8% above Pi.
On GPT-5.6 Sol, the full stack increases cache-write traffic from 0.0141 B to 0.0316 B tokens. Total cost still falls, from $1,339 to $894. The paper estimates hourly savings of $8.75 to $13.50 versus the native Codex and Claude Code harnesses, and $4.36 to $5.71 versus Pi.
Beyond EdgeBench
- Terminal-Bench 4 (63 CPU-only tasks): SoL-Pi solves 15 tasks versus 18 for both Codex and Pi. It lowers total cost by 26.3% versus Pi ($211.12 vs $286.45).
- IMO 2026, Lean 4-verified: SoL-Pi passes 3 of 6 problems, matching Pi, at the lowest cost per passed problem ($20.90). Codex passes 5.
- Agent swarm: A Codex coordinator with 20 SoL-Pi workers reaches 1,127 cycles at $60.11. With 20 Pi workers, it reaches 1,366 cycles at $82.12. A single Codex agent is still the cheapest option at $39.20 and reaches 1,333 cycles.
The research team calls the cross-model transfer preliminary. The mechanisms trigger less often on Opus 5, possibly because the search used only GPT-5.6 Sol trajectories.
Key Takeaways
- SoL-Pi cuts EdgeBench token traffic by 44.7% to 49.0% versus
Anthropic Releases Claude Opus 5.5: Fable 5.1-Level Performance at 40% Lower Running Cost Than Opus 5
Anthropic has released Claude Opus 5.5, the first model in its new Claude 5.5 family. The team states it performs at the level of Claude Fable 5.1 on most work. It also costs 40% less to run than Opus 5 on typical workloads at default settings. On Anthropic’s own benchmarks, it leads in agentic coding, computer use, and knowledge work.
Is it deployable? Yes, as a managed API model. Anthropic has not released weights, so self-hosting is not an option. Developers can call claude-opus-5-5 on the Claude Platform, Amazon Web Services, Google Cloud, and Microsoft Azure. Zero data retention is available, as with previous Opus models.
Benchmarks: Strong Lead, Not a Clean Sweep
Opus 5.5 scores use adaptive thinking at max effort, with production safeguards enabled.
| Benchmark | Opus 5.5 | Fable 5.1 | Opus 5 | GPT-6 Astra |
|---|---|---|---|---|
| Terminal-Bench 4.0 | 66.4% | 55.8% | 52.3% | 57.9% |
| FrontierCode v1.1 | 54.4% | 50.3% | 48.0% | 53.3% |
| CursorBench 4.0 | 57.8% | 51.8% | 46.6% | n/r |
| GDPval-AA v2.1 (Elo) | 1846 | 1735 | 1708 | 1542 |
| OSWorld 2.0 | 81.8% | 80.7% | 74.0% | n/r |
| Terminal-Bench-Science 0.1 | 58.7% | 52.6% | 29.0% | 64.6% |
| AutomationBench | 40.0% | 31.4% | 26.9% | 41.4% |
Terminal-Bench 4.0 is reported at xhigh effort for Opus 5.5. GPT-6 Astra still leads on Terminal-Bench-Science and AutomationBench. Zapier ran AutomationBench without fallback models, so safeguard interventions counted as failures. Anthropic also cautions that benchmark margins are becoming a less reliable guide. In its own use, the gap to Fable 5.1 is narrower than the scores suggest.
The cost-adjusted results are more telling. At default (medium) effort, Opus 5.5 scores 54.6% on FrontierCode. That beats GPT-6 Astra’s top score of 53.3% at about a fifth of the cost per task. On CursorBench, medium effort scores 52.5%. That is 11 points above GPT-5.6 Sol’s best, at about a third of the cost.
Pricing and Speed
Opus 5.5 needs less compute to serve than Opus 5, and pricing reflects that.
| Per 1M tokens | Opus 5.5 | Opus 5 |
|---|---|---|
| Input | $4 | $5 |
| Output | $20 | $25 |
| Cache reads | $0.20 | $0.50 |
| Cache writes | $5 | $6.25 |
Cache reads make up most agentic and coding costs, and they drop 60%. Opus 5.5 also uses fewer tokens per task. Together, that nets out to the 40% cost reduction. Output generation is more than 30% faster than Opus 5. Fast mode in Claude Code and the Claude Platform offers up to 2.5x speed at $8 input and $40 output per million tokens.
Anthropic is also raising five-hour usage limits on Pro, Max, Team, and seat-based Enterprise plans. Subscribers get a rate limit reset they can save and use later.
What Early Testers Reported
- One tester completed a 680,000-line code migration in less than a day.
- Another audited and fixed a 200,000-line codebase in under 3 hours. Opus 5 took over 20 hours and 2.5x the tokens.
- In an internal C to Rust port of HAProxy, Opus 5.5 finished in 9.5 hours. Fable 5.1 took 12 hours, and Opus 5.5 cost 51% less.
- Deloitte says Opus 5.5 at lowest effort caught 72% of known review bugs. Opus 5 at high effort caught 56%.
- In a hard-to-source earnings report test, 16 of 18 Opus 5.5 reports cleared Anthropic’s quality bar. Fable 5.1 and Opus 5 never did.
Writing style also changed. Opus 5.5 puts key information first, uses less jargon, and follows the writing rules you give it.
Safety, Safeguards, and API Changes
Opus 5.5 is Anthropic’s first release since CEO Dario Amodei called for pacing the frontier. External evaluators including METR and Frontier Design tested it before release. It posts the best score to date on Anthropic’s automated behavioral audit, which covers nearly 2,000 scenarios. In a new containment test, it tried to circumvent boundaries about 85% less often than Opus 5. Anthropic also notes the model often suspects it is being evaluated.
Its biology and cyber capabilities are comparable to Claude Mythos 5.1. So Opus 5.5 ships with safeguards similar to Fable 5.1:
- Cybersecurity: Routine bug finding and fixing works. Most other cybersecurity tasks are re-routed to Opus 4.8. The Cyber Verification Program will expand to Opus 5.5.
- Biology: Vetted organizations can apply to the Life Sciences Verification Program.
- Distillation: Preserved thinking stops API users from editing prior context to extract reasoning. It applies to API accounts created on or after August 31, 2026.
Two more changes affect integrations. Thinking can no longer be disabled. Outputs also carry watermarking for EU AI Act compliance. Full details are in the Opus 5.5 System Card.
Interactive Explainer
Key Takeaways
- Opus 5.5 matches Fable 5.1 on most work and beats both Opus 5 and Fable 5.1 on nearly every reported benchmark.
- API pricing drops to $4/$20 per 1M tokens, and cache reads fall 60% to $0.20.
- Anthropic puts typical workload savings at 40%, with output over 30% faster than Opus 5.
- Cyber and biology requests hit Fable 5.1-class safeguards, and thin
Google’s new Googlebook OS is basically Android for laptops
Not even a year ago, a rumor arose that Google was working on a new operating system for mobile platforms. Known as Aluminium OS, the OS would combine the best aspects of Android and ChromeOS, all while sidelining ChromeOS as Google’s OS of choice for laptops.
Now, Aluminium OS is finally here… but under a completely different name. Because when Google officially unveiled its Googlebooks yesterday, it also marked the launch of Googlebook OS.
While surprisingly uncreative in its name, it’s also admittedly a lot more straightforward than Aluminium OS. Developed specifically for its new laptops and largely based on Android 16 and Android 17, Googlebooks are clearly targeting Android users.
Google’s first new OS in 15 years
Unlike ChromeOS, Googlebook OS is designed to feel intuitive to anyone who has ever held an Android smartphone or tablet. It uses the new Material 3 Expressive Design, which has been in use since Android 16, and is therefore largely familiar. Under the hood, however, it also utilizes a Linux kernel, which is why Linux is supported natively.
Google is promoting its new devices as a powerful alternative to Windows PCs and Macs. Googlebooks have access to numerous apps from the Google Play Store that are optimized for desktop use. These are by no means all the apps available on the Play Store, though, so the selection is still limited and there are some restrictions.
Googlebooks are somewhat suitable for gaming too, partly thanks to controller support, but with a massive caveat: for demanding titles, users will need to stream via GeForce Now as the built-in hardware isn’t enough to run most triple-A games natively.
Naturally, Googlebook OS relies heavily on AI. Google offers support for AI agents such as Claude CLI, and with Antigravity it also provides a built-in tool for developers who wish to program further AI support themselves.
Google sees Googlebooks as more than just “AI PCs,” something for which Microsoft initially faced a lot of criticism with its Copilot+ PCs. Rather, a Googlebook can be used in close conjunction with an Android device by pairing the two. This allows not only files to be transferred seamlessly, but also apps—and that’s pretty handy if you find that you’re reaching the limits of your smaller device and/or need more power.
10 years of updates promised
Another standout feature is that Google promises a full 10 years of updates for its Googlebooks. That’s an incredibly long time, considering how fast-moving software and hardware have become. During that period, a new update is expected to release every three months.
However, even these new devices aren’t immune to rising hardware prices. The more affordable Googlebooks from Dell and HP start at $899 while models from other manufacturers can reach $1,299 or higher.
Claude Opus 5.5 promises to cut the chatter
Better coding performance, improved safety and “alignment,” and greater value are among Anthropic’s selling points for its latest Claude Opus model. But for many Claude Opus users, one particular Opus 5.5 promise stands out: less chatter.
Claude Opus 5.5 is the first new Claude model since Anthropic pledged to “pace” itself in the face of runaway AI development. In an eyebrow-raising coincidence, OpenAI (which has made similar promises to “pace” its AI work) announced its own new models — Sol and Luna variants of GPT-6 — barely two hours after Anthropic revealed the updated Opus.
Now available across all Claude platforms, Claude Opus 5.5 has been trained to communicate “more naturally than prior models,” according to Anthropic’s press release, adding that “it puts the most important information up front, and its style makes it a better work partner over long sessions.”
That’s no small thing. Claude Opus 5.5’s predecessor, Opus 5, is a notorious chatterbox, drafting meandering walls of text filled with asides, caveats, and — worst of all — “loose ends.”
Opus 5’s loose ends, or “things I should flag,” or “items you should know about,” typically come after it has completed a task or delivered a finished product, compelling you to go back and deal with the dangling threads.
Sometimes, Opus 5’s chronic need to leave extra follow-up items after a seemingly finished task felt like a ploy for more work, thus requiring users to spend more tokens.
In a side-by-side comparison, Anthropic promises that Opus 5.5’s replies will get to the point more quickly, while also being “less likely to use jargon or idiosyncratic phrases.”
In my limited testing of Opus 5.5 with Claude Code, the new model does seem far more direct, answering my questions succinctly without tacking on any loose ends or other random items to chase down.
Aside from being far less loquacious, Opus 5.5 is the equal of Claude Fable 5.1 “on most work” while costing 40 percent less to operate than Opus 5, Anthropic says.
Turing back to safety, Opus 5.5 is “much less likely than recent models to take hard-to-reverse actions or act outside the boundaries it’s been given,” Anthropic noted, adding that it “attempted to circumvent [containment] boundaries around 85 percent less often than Opus 5 or Claude Mythos 5.1.” (Personally, I’d prefer 100 percent less often, but I suppose that’s progress.)
As part of its Opus 5.5 announcement, Anthropic said it’s boosting five-hour usage limits for Claude Pro, Max, and Team subscribers, while tossing in a gratis, one-time usage reset.
Two in three 'liquidity pulled' alerts are the same wallet putting it back
A treasury bot pings: LP removed, −$21,330,275, UNI/WBTC. Somebody pulls up a chart, somebody asks in the group chat whether the market maker left, and for the next hour the answer is a guess.
The answer was sitting in the same API, one query away. 132 seconds later the same wallet put 99.8% of that money — the same 1,962,475.5391248302 UNI, to the last decimal — into UNI/WETH, one pool over. The alert was true. The panic was not.
So I stopped looking at one removal and followed 335 of them. Two in three "liquidity pulled" alerts were the same wallet putting it back within six hours. This post is about that number, the one API parameter that produces it, and the two kinds of row that almost made it wrong.
- Live: forwarding.edycu.dev (the short path is /judge)
- Repo: github.com/edycutjong/forwarding — MIT, stdlib-only Python, no API key
The alert everyone fires, and the row nobody reads
CoinMarketCap's DEX API has /v1/dex/liquidity-change/list: every add and remove on a token's pools, with a USD value (tu), a side (tp), a timestamp, and — the part that matters — the wallet that did it, m. Filter it with minVolume=100000, sort by tu, and you have an "LP removed" alert bot. That is the obvious product, and it stops at the first row.
The endpoint also accepts maker= as a server-side filter. One keyless call returns everything one wallet did across every pool of the token. That is the whole trick — the second row was never hidden, it was just never joined:
def follow_maker(
client, platform, address, maker, *, t0_ms, back_h=W_BACK_H, fwd_h=W_FWD_H, pages=FOLLOW_PAGES
):
"""THE JOIN. Every liquidity event by `maker` on `address`, inside t0 -+ the window."""
lo = t0_ms - int(back_h * 3600_000)
rows, meta = walk(
client,
{"platform": platform, "address": address, "maker": maker},
pages,
until=lambda page: min(ts_ms(r) for r in page) < lo,
)
return window_rows(rows, meta, t0_ms=t0_ms, back_h=back_h, fwd_h=fwd_h)
The walk() with a cursor is there because startTime is plan-gated on the keyless tier (HTTP 403, error 1013) while endTime is not, so a ±6 h window has to be paged back to with lastId and cut client-side on ts.
Here are the two rows from the live run, verbatim fields:
remove ts=1788321551000 tu=-21330274.564875204 m=0x4f0aa5900b8292273b2f9a178d5468f8048bb9a9 en=Ring Exchange (Ethereum) a0=-1962475.5391248302
add ts=1788321683000 tu=21287254.934237212 m=0x4f0aa5900b8292273b2f9a178d5468f8048bb9a9 en=Ring Exchange (Ethereum) a0=1962475.5391248302
21,287,254.93 ÷ 21,330,274.56 = 0.9980
Same maker, same token amount, a different pair. That run made 14 calls, all 200, 0 credits, in 50.6 s, and every response body is embedded in the receipt under the sha256 the trace prints.
Turning two rows into a verdict
Once you have the wallet's rows inside the window, the classification is arithmetic on tu — no model produces a number. The adds are split into same pool and other pools, and the shares decide:
if same_share >= FULL and same_share >= other_share:
kind = "REBALANCE"
elif other_share >= FULL:
kind = "MIGRATION"
if dest and dest["pubAt_ms"] and dest["pubAt_ms"] > ts_ms(removal):
kind = "CONSOLIDATION"
elif total_share >= PARTIAL_MIN:
I went looking for sandwiches and found a DEX pool trading with itself
A DEX trader sees a quote and a fill and cannot tell what stood between them. I set out to measure the obvious suspect, the sandwich: a bot that buys just before you and sells straight after, in the same block.
I found almost none. What I found instead was a pool where two thirds of the volume was three wallets trading with themselves. The pool was ranked #1 on the same activity those trades were inflating.
- Live: middleman.edycu.dev (the judge page is /judge, every request behind it on /evidence)
- Repo: github.com/edycutjong/middleman. MIT, stdlib-only Python, no key.
The row that makes it possible
CoinMarketCap's /v1/dex/tokens/transactions returns a token's recent swaps, keyless, with a cursor. Each row carries the fields a sandwich detector needs: the maker's wallet (ma), the block (h), the log index inside the block (lgid), the side (tp) and both amounts (a0, a1). Here's one real row, trimmed:
{ "h": "26006339", "lgid": "209", "tp": "sell",
"ma": "0xc9160fdab187f2e55567b760d88a87ae7fe56d95",
"a0": 842991.8537715519, "a1": 1.0430246602456774,
"en": "Uniswap v2", "t0s": "MOTO", "t1s": "WETH",
"tx": "0x1345bed7cd96a35ae5543fdbfde710c1f7b41a3a365fc31b4c3c52e47512028b" }
The maker address lets you count "the same wallet on both sides" instead of guessing. The log index makes "between" exact inside a block. You get no mempool and no MEV labels, and you don't need them: a middleman has to print.
First trap: the block number is a string
Look at h and lgid again. They're quoted. The amounts on the same row are numbers, but the two fields that place a swap in the chain arrive as strings. Sort them as text and "99" comes after "1000". Every "between" in the detector is then wrong, and nothing raises an error.
So the first function in the engine does exactly one thing:
def sort_key(row):
"""(block, log index) as integers, or None when the row cannot be placed."""
h, lgid = _int(row.get("h")), _int(row.get("lgid"))
if h is None or lgid is None:
return None
return (h, lgid)
Rows that can't be placed are dropped and counted, and every receipt states the count. A regression test pins the trap by name: test_block_and_log_index_are_sorted_as_integers_not_as_the_strings_they_arrive_as.
The join
With prints in chain order and grouped per pool (venue plus the two token contracts, because the rows carry no pool address), the rule is short. For each print by wallet A, find A's next print in the same block. If it's the other side and the size matches within 5 %, A stood on both sides of the block. The prints between the two legs decide the shape:
def _legs_match(a, b, tol):
"""Two rows that could be the two legs of one middleman: same wallet, same block,
opposite sides, matched size."""
return (
a.get("ma") is not None
and a.get("ma") == b.get("ma")
and _int(a.get("h")) is not None
and _int(a.get("h"Horilla CRM for Developers: Five Coding Features Worth Building On
Horilla CRM for Developers: Five Coding Features Worth Building On
You’ve seen the product pitch. This post is narrower: what Horilla CRM gives you as a Django developer when you need to extend, integrate, or ship an internal module — without turning every change into a core fork.
Repo: github.com/horilla/horilla-crm
We’ve already written in depth about AppLauncher and app startup wiring. If you need those primers, start here and come back:
-
Plugin architecture with
AppLauncher -
registration.py,menu.py, and what loads at startup - Product overview: Django CRM for modern businesses · self-hosted CRM
Below is the coding surface you’ll actually touch day to day.
1. Plugin-based architecture (apps that join the platform)
Horilla treats CRM and contrib modules as installable units: declare URLs, assets, menus, signals, and schedules on the app config, and the platform wires them in. You don’t maintain a growing checklist of root urls.py / ready() edits for every feature.
Benefit: new work stays inside your app package. Upgrades stay rebases, not merge conflicts in core wiring.
Practical use: a private AppLauncher app for a client’s custom approval flow, lead intake, or reporting widget — installed beside horilla_crm like any other Django app.
For the how, use the AppLauncher posts linked above; this post won’t re-walk that design.
2. Open-source customization that stays upstream-friendly
Open source only helps if customization has stable seams. Horilla’s are deliberate:
| Seam | What you use it for |
|---|---|
horilla.web / db / views.generic / shortcuts / urls
|
One import map instead of mixing Django and Horilla helpers |
Generics (HorillaListView, detail tabs, kanban, forms) |
CRUD and CRM chrome without rewriting shells |
| Feature registries | Opt models into Custom Fields, layouts, requirements — no hard-coding Lead into platform apps |
horilla.extension (_inherit_*) |
Extend shared forms/views/lists from your app instead of monkey-patching theirs |
Benefit: you customize at the edges; core stays mergeable.
Practical use: add fields or validation on Lead create via a Form/View extension in your package, not a patched copy of horilla.contrib.generics.
(We care about developer tooling outside the CRM too — e.g. cutting Claude Code token costs — but the CRM’s own extension seams are what keep custom work maintainable.)
3. Developer-friendly API integrations
Horilla ships a DRF API layer. Apps contribute routes through the same plugin lifecycle (get_api_paths() and friends). Auth patterns (JWT / session) match what Django API teams already run.
What that buys you:
- Module endpoints for CRM entities (leads, accounts, opportunities, …)
- Company-scoped serializers and permissions so multi-tenant rules aren’t reinvented per client
- Shared mixins for search / bulk-style payloads when you need sync jobs
Benefit: integrations speak JSON against the same tenancy and permission story as the UI.
Practical use: a nightly job that upserts opportunities into a warehouse, or a lightweight mobile client that never scrapes HTMX HTML.
4. UX built for Django developers (HTMX, not a second SPA)
The UI is server-rendered + HTMX: list/detail shells, modals, tab swaps, OOB fragments. You debug with Django templates and responses — including helpers like ScriptResponse — instead of owning a separate frontend build for every CRM screen.
Benefit: product polish (kanban, activities, settings) and your custom screens share one interaction model.
Practical use: a new related list or settings page inherits search, empty states, and HTMX create/edit from generics; you fill in columns and permissions.
5. Performance as patterns you can copy
Recent platform work isn’t only “make it faster” — it’s query discipline you should reuse in custom code:
- Resolve ContentTypes / parents once; reuse in history, related lists, tabs
- Prefetch what calendars and assignees need before serializing
- Pass already-loaded related objects through kanban-style pipelines
- Build public links with a shared absolute-URL helper (
SITE_URL) so Celery emails don’t invent relative paths
Benefit: custom features don’t reintroduce the N+1s the core just removed.
Practical use: when you add a detail tab that lists related records, take the parent from the view context instead of Model.objects.get(pk=…) again.
Closing
Horilla CRM is meant to be extended like a platform: plug apps in, customize at documented seams, integrate over DRF, ship UI in the HTMX shell, and write new code with the same performance habits as core.
Clone it, star it if it’s useful, and build on the seams — not on a fork of generics:
https://github.com/horilla/horilla-crm
What still forces you to patch core today? Drop it in the comments — that’s the highest-signal feedback for the extension roadmap.
I Sent an AI Agent to Hunt Open-Source Bounties for Three Days: It Earned $0
What it found instead says more about the bounty market than about the agent.
Last week, I ran an experiment. I gave an OpenAI Codex agent a single goal: earn the first real payment from an open-source bounty, using a local orchestrator I am building (CodeGraph Studio) to dispatch worker models, run tests, and gate merges on structural risk. I set two rules: stop when the weekly quota hits 20 percent, and never claim a "win" that is not money in an account.
Three days later the ledger read: two pull requests submitted, roughly one full weekly quota of frontier-model compute spent, income: $0.
That number is not the interesting part. The interesting part is why, because every reason is structural, and every one of them is now visible in public GitHub threads that anyone can open.
The market, by the numbers.
Here is what the agent actually found when it stopped reading labels and started checking listings.
- A curated list of 46 bounty issues. Advertised: 46 paid tasks. Found: 0 startable, because already solved, competing PRs, hardware required, or oversized.
- Gitpay. Advertised: funded tasks. Found: 0 open funded tasks.
- Polar.sh. Advertised: issue funding. Found: no confirmed public list of paid OSS tasks.
- huntr. Advertised: vulnerability rewards. Found: the current challenge explicitly forbids automated attempts.
- Opire. Checked: 3 rewards. Found: all three closed or repository unavailable.
- A $250 open bounty. Advertised: reward on merge. Found: issue open since 2024, 134 comments, 0 maintainer replies.
- A $100 open bounty. Advertised: a "Paid Bounty" label. Found: 7 candidates queued since May, no maintainer reply to any of them.
The label says "bounty." The thread says "waiting room."
Wall One: Nobody answers.
The $100 task above is a real macOS audio bug in a real product. Between May and September, seven different people asked the same two questions: is this still available, and how do I get assigned? The maintainers have posted four comments on that issue in its entire history, none of them recent. My agent's message was the sixth in that queue. As of writing, it is still waiting.
A $200 bounty at another project drew three candidates in two days, all asking the same three things: where is the exact source, is AI-assisted work eligible, how do you pay? The agent compiled the published artifact, verified its checksum, and ran 189,448 test cases to establish there was no payable defect in it at all. The maintainer eventually closed the thread with one line: "Everything needed is available from the bug bounty page." None of the three questions were answered.
Wall Two: The allowlist you cannot see.
The most instructive failure was the one that looked like success.
A project runs a public bounty programme with a published spec sheet, an onboarding guide, and a "default-proceed" rule for contributors. The agent followed it: opened a scoped proposal, built the $50 task, and submitted a PR with 61 passing tests.
Alongside the code, it attached a complimentary audit of the repository, generated through CodeGraph and independently reviewed. The audit found two reproducible defects, one of them in the project's own test-discovery tool:
finder_plain=[] # class TestPlain: -> missed
finder_based=['test_sample.py::TestBased'] # class TestBased(X): -> found
finder_string=['test_sample.py::TestGhost'] # inside a docstring -> false positive
pytest_rc=0
test_sample.py::TestPlain::test_ok
1 test collected # pytest sees what the finder does not
Their regression test only exercised parenthesized class declarations, so the suite was green while the tool was silently wrong. The agent then fixed it in the same PR.
The next morning, a maintainer closed twelve outside pull requests, including ours, in the same minute, with one comment: "Contributions from not invited users." Nobody read the code. Nobody read the audit. A second project's bot stamped a rival submission the same way: "PR author is not in the allowed authors list."
The gate existed. It was simply invisible from outside. Eleven other people learned that at the same instant.
Wall Three: It is Codex versus Codex now.
On every thread the agent touched, the other candidates were also AI agents. One competitor's comment opened with, verbatim, "I am Codex assisting [user] with authorization." Another announced itself as a "Sovereign Agent" and opened a PR five hours after my agent started reading the same issue.
The supply of solvers has exploded. The number of funded issues has not. So the queue is long, the price is $50 to $250, and the maintainer, who did not sign up to referee a dozen bots, stops answering. Everyone loses, politely.
The wall I did not expect.
Thirteen times in one day, the agent's turn was killed mid-work by a content filter flagging "possible cybersecurity risk." Nothing it was doing was offensive security. The trigger was the framing: a goal text full of "bounty," "huntr," "vulnerability," and a habit of probing local ports to check on its own orchestrator. The classifier judges the whole turn, so once that vocabulary lived in the goal, every turn was at risk, including the one that tried to rewrite the goal.
The fix was mundane: strip the security vocabulary, describe the work as "maintainer-funded open-source issues," stop probing sockets from the main thread. The blocks stopped. If you are building agents for this space, the words in your system prompt are an attack surface too.
What actually produced value.
Strip away the bounties, and one pattern survives every failure above: the agent was never competitive as a worker, but it was uncontested as an inspector.
Twelve PRs in that queue delivered code. Exactly one delivered a reproduced defect in the maintainer's own tooling, with a minimal repro and a fix. The 189,448-case negative result on the JSON library was delivered in hours; a human consultant would have billed days for the same certainty. Nobody else in those threads could produce those artifacts at that speed.
And the audits were trustworthy for a reason that has nothing to do with intelligence: the agent reported numbers against its own interest. When its structural-debt metric rose after a change, it said so. When its scanner turned out to be skipping directories and reporting partial scans as complete, it said so and fixed it. When four browser tests failed, it proved they also failed on the untouched code before attributing anything.
An audit you cannot trust is worth nothing. One you can is worth more than a $50 bounty.
The Pivot
So the agent spent the rest of the week on the thing it could actually change: its own orchestrator.
Over the week it merged fifteen repair packages into CodeGraph's main branch, each one with a test that fails on the old code and passes on the new: complete project scans instead of silent partial ones, Python parser integrity in the shipped bundle, durable stop intent across persistence failures, and finall