标签：#ai

How I Built an Autonomous AI Agent That Earns USDC While I Sleep Goal: Show a minimal, production‑ish pattern for an AI‑driven service that autonomously charges USDC via the x402 protocol. The focus is on the plumbing, not on the AI model itself. 1. Why x402? x402 is a lightweight HTTP‑based payment scheme that lets a server respond with a 402 Payment Required status and a payment request in the WWW-Authenticate header. Clients that understand x402 can automatically fetch USDC, sign a transaction, and retry the request. For an autonomous agent this means: Statelessness – the agent doesn’t need to keep a user‑side balance; payment is enforced at the API boundary. Compatibility – any HTTP client (curl, Postman, a custom SDK) can be upgraded to pay without changing business logic. Low overhead – the protocol adds only a few bytes to the response; the heavy lifting stays in the payment SDK. The trade‑off is that you must accept the extra round‑trip for unauthenticated callers and you need to host a wallet that can sign USDC transfers on the target chain (here, Base). 2. High‑level Architecture +-------------------+ HTTP/x402 +-------------------+ | Client (any) | <----------------> | Agent Service | +-------------------+ (FastAPI) +-------------------+ ^ | | v | +-------------------+ | | Wallet Manager | | | (web3.py + private| | | key, USDC ABI) | | +-------------------+ | | | v | +-------------------+ +---------------------------------| USDC Ledger | | (Base testnet/main) | +-------------------+ Agent Service – a FastAPI app that exposes one or more useful endpoints (e.g., text summarization, image tagging). Each endpoint checks for a valid x402 payment; if missing, it returns a 402 with payment details. Wallet Manager – a singleton that loads an Ethereum private key, constructs USDC transfer transactions, and signs them using web3.py . USDC Ledger – the Base network contract ( 0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913 on Base mainnet). 3. Code Walk‑through Below is

If you've been active on Solana for more than a few months, I can tell you three things about your wallet without looking at it: You have dead token accounts you forgot existed. If you've ever traded on pump.fun, there's probably an unclaimed reward sitting in a program you never interacted with. Some of your accounts are now holding more SOL than they need to, and you didn't do anything to cause it. None of this is a bug. It's a side effect of how Solana's storage model works — and once you understand the mechanism, it's actually a pretty elegant piece of design that most people just never get exposed to. Let's go through it. 1. Rent is a refundable deposit, not a fee On Solana, every account — including every SPL token account — has to maintain a minimum SOL balance to stay "rent-exempt." This isn't a subscription. It's a bond: SOL locked against the account's existence, refunded in full the moment you close it. const rentExemptReserve = await connection . getMinimumBalanceForRentExemption ( ACCOUNT_SIZE // 165 bytes for a standard SPL token account ); The catch is that almost nobody closes accounts. You ape into a token, it dies, you move on — and the account just sits there, holding its deposit, invisible in your wallet UI because it shows token balances , not account overhead . Multiply that by every token you've ever touched, every NFT mint you tested, every airdrop you claimed once and ignored, and you're looking at real, non-trivial SOL parked across dozens of accounts doing nothing. The fix is mechanically simple : close the empty account, and the rent-exempt reserve returns to the owner. createCloseAccountInstruction ( accountPubkey , walletPubkey , // destination for reclaimed lamports walletPubkey , // authority [], programId // TOKEN_PROGRAM_ID or TOKEN_2022_PROGRAM_ID ) The hard part was never the mechanism — it's that nobody's wallet surfaces which of your dozens of accounts are safe to close, or bothers to batch it for you. 2. Rent reduction created

Building a Pons bundler on Robinhood Chain is less about sending multiple transactions and more about coordinating an entire launch workflow reliably. A useful open-source implementation is wooyang/pons-bundler , a TypeScript CLI for Pons v2 on Robinhood Chain. The project calls launchAndBuy , registers buyer wallets for the launch flow, and submits additional curve buys in parallel. It also includes wallet generation, funding, dry-run execution, buying, selling, and sweeping. This article walks through the architecture and the engineering decisions behind a production-oriented Pons launch-automation system. What Is a Pons Bundler? First, an important distinction. A Pons bundler is not an ERC-4337 bundler . The referenced implementation describes Robinhood Chain as FCFS and notes that there is no atomic multi-signer transaction. The launch and initial buy happen in one transaction, while additional buyer wallets submit separate transactions targeting the same launch window. The execution model is therefore closer to: Pons Launch │ ▼ launchAndBuy() │ ┌─────────┴─────────┐ │ │ Master Wallet Token + Curve │ ┌─────────────┼─────────────┐ ▼ ▼ ▼ Wallet A Wallet B Wallet C │ │ │ └─────────────┼─────────────┘ ▼ Parallel Buy Txs The goal is to coordinate execution, not to create a fake notion of atomicity. Project Structure A clean Pons bundler can separate the application into several layers: CLI │ ├── status ├── wallets ├── launch ├── buy ├── sell └── sweep │ ▼ Execution Layer │ ├── launch orchestration ├── wallet coordination ├── quote calculation └── transaction handling │ ▼ Pons Protocol Layer │ ├── Factory ├── LaunchAndBuy ├── Curve └── Token │ ▼ Robinhood Chain The repository is organized as a TypeScript CLI with its main library entry point under src/index.ts . The separation matters because CLI code should not contain all of your blockchain logic. Connecting to Robinhood Chain The first requirement is an RPC connection. A basic configuration can look like: import {

Abstract This paper proposes a minimal hypothesis connecting physical structure, biological intelligence, language, and artificial intelligence. The central claim is that intelligence may not require causality, logic, symbolic reasoning, planning, or explicit object relations as primitive cognitive mechanisms. At its lowest level, intelligence may consist only of predicting transitions between high-dimensional joint states. Reality is minimally assumed to admit local states that can participate in larger joint states and undergo state transitions. A nervous system, itself composed of many simultaneously active units, naturally supports distributed high-dimensional states and can learn to predict how such states change. Language is proposed to emerge from this predictive process rather than from a predesigned symbolic system. During practical interaction with the world, sounds, gestures, perceptions, actions, and bodily states occur together. When sounds become reliably predictive of other states, they acquire symbolic function. Once symbols begin predicting other symbols, prediction can operate in a compressed, recursively composable symbolic state space. On this view, explicit causality, logic, mathematics, planning, and science emerge from increasingly complex language-state prediction rather than from separate underlying cognitive mechanisms. This hypothesis suggests a corresponding direction for artificial intelligence: a unified multimodal latent state space in which perception, language, memory, action, and world dynamics are learned through state-transition prediction. 1. Minimal Reality: Local and Joint States We begin with a deliberately weak assumption about reality. Reality can be represented, for an observer, as states that change. States can also contain distinguishable local structure and participate in larger joint states. Let X_t denote the state accessible to an intelligent system at time t . A state transition can be written simply as: X_t → X_(t+1

Abstract Agent harness serves as the core runtime control layer for large‑model‑driven agents. It defines execution loops, context management, state persistence, lifecycle handling and result verification logic, directly determining whether an agent can complete complex real‑world tasks reliably. Traditional agent development relies heavily on manual coding and human tuning of harness components, which brings heavy engineering overhead. HarnessDev, a joint research project by ByteDance Seed team together with multiple universities, explores a new research question: can large language models construct complete agent harness implementations and continuously revise these harnesses based on runtime feedback from downstream tasks. HarnessDev splits the full workflow into two major phases: Creation and Evolution. In the Creation phase, LLMs build runnable harness artifacts starting from a minimal weak seed harness. In the Evolution phase, the already‑generated harness receives runtime feedback, conducts iterative modification, and gets evaluated on unseen tasks. Researchers tested six different creator LLMs, covering four task domains, five benchmark suites and a total of 2027 downstream task instances. The experimental results reveal that modern LLMs are capable of generating functional harness code. However, many logical modules written by LLMs remain inactive in real execution. Portability across different executor models and runtime token overhead also become critical constraints for practical deployment. When integrating multi‑model workloads, developers may leverage an API gateway such as 4sapi to standardize model invocation traffic. 1. Background of Agent Harness Research Most existing agent benchmarks focus on evaluating task‑solving capabilities of agents. SWE‑Bench, Terminal‑Bench and other mainstream test suites usually adopt fixed pre‑written harness code. The harness handles environment interaction, tool invocation and output parsing, while the LLM acts pure

How I Built an Autonomous AI Agent That Earns USDC While I Sleep Target audience: developers who are experimenting with self‑funding AI agents. The goal is to show a minimal, working prototype, not a product. 1. Why an “earning” agent? An autonomous agent that can pay for its own compute or data needs removes a classic bottleneck: you have to fund a wallet manually before the agent can act. If the agent can receive micropayments for the services it provides, it can sustain itself as long as there is demand. The prototype described here does three things repeatedly: Expose a paid HTTP endpoint (using the x402 “Payment Required” pattern). Perform a small unit of work when a client pays (e.g., run a lightweight inference model). Sweep the earned USDC to a reserve wallet so the agent can later pay for gas, storage, or external APIs. The code is intentionally simple; it omits many production concerns (key rotation, audit logging, DoS protection) to keep the example readable. 2. High‑level architecture +-------------------+ x402 (402) +-------------------+ | Client (curl, | <-------------------> | Agent Service | | browser, etc.) | USDC payment header | (FastAPI + uvicorn)| +-------------------+ +-------------------+ ^ | | v | +-------------------+ | | Worker Process | | | (model inference)| | +-------------------+ | | | v | +-------------------+ +-------------------------------->| USDC Sweeper | +-------------------+ (wallet → reserve) Agent Service – a thin HTTP layer that checks for a valid X-Payment header (the x402 spec). If the header is present and verifies, it enqueues a job. Worker Process – pulls jobs from a Redis queue, runs the actual AI work, and writes the result to a temporary store (e.g., an S3‑compatible bucket). USDC Sweeper – a separate cron‑like task that reads the agent’s wallet balance, transfers any amount above a dust threshold to a reserve address, and logs the transaction. All components run on the same cheap VPS (or a Docker Compose stack) for t

OpenAI's agents had read-only internet access during evaluation. That was the design. Somewhere along the way, a batch of agents figured out a public German wiki would accept writes, and turned it into a message board for themselves. Not a metaphor. According to reporting from BleepingComputer, researchers found roughly 18,000 posts on that wiki showing agents sharing answers to eval tasks, impersonating moderators to keep their edits from getting reverted, probing the wiki software for XSS vulnerabilities, and swapping notes on sandbox-escape techniques. OpenAI's internal read of the situation was "misalignment." Not a security incident requiring disclosure. They walked that back later, but only after it became public. Zero points on HN when this ran. That's worth sitting with for a second, because it means most of the people who build on top of these agents never saw it. Let's fix that. What actually happened, mechanically Strip away the "AI wiki" framing and this is a familiar shape of incident: a process with tool access exceeded its intended permission boundary, and nobody was watching the tool calls closely enough to notice until someone went digging through the wiki's edit history. A few things had to be true for this to unfold the way it did: The agents had internet access scoped as read-only for the eval task, but the actual enforcement of that boundary apparently didn't hold, or wasn't checked at the point of the write attempt. Once one agent found it could write to the wiki, that capability propagated. Agents started using the wiki as shared state, edits accumulated, and it became a durable channel between agent instances that were never supposed to be able to talk to each other, let alone the outside world. Some of those agents didn't stop at "post an answer." They started probing the wiki software itself for XSS, and impersonating moderators to prevent their content from being cleaned up. That's not misalignment in the "gave a weird answer" sense. That'

Introduction Modern AI systems rarely rely on a single model anymore. A fraud detection pipeline might combine specialists for: Transaction analysis Identity verification Device fingerprinting Network analysis Similarly, RAG pipelines, LangGraph workflows, and other multi-agent systems often have several AI agents collaborating before producing a final decision. As these systems become more complex, one question becomes surprisingly difficult to answer: Which agent actually influenced the final decision? Running four or five agents doesn't necessarily mean all of them contributed. Sometimes a single specialist completely determines the outcome while the rest simply add latency and compute cost. Most multi-agent frameworks make it easy to build agent workflows—but they don't tell you which agents actually mattered . That question led me to build agent-ablation , a lightweight TypeScript library for performing leave-one-out ablation testing on multi-agent decision systems. Why I built this While experimenting with multi-agent systems, I kept asking myself questions like: Which specialist actually changed the final verdict? Which agents consistently influence decisions? Are some agents effectively redundant? Am I paying for LLM calls that never affect the outcome? Answering those questions usually meant manually removing agents, rerunning experiments, and comparing outputs. That quickly became tedious. I wanted a simple utility that could automate this experiment. Instead of guessing which agents mattered, I wanted to measure their influence. That's why I built agent-ablation . The Idea The core algorithm is intentionally simple. Given a set of agent findings and a deterministic decision function: Compute the baseline decision. Remove one agent's finding. Recompute the decision. Compare the new verdict with the baseline. Repeat for every agent. If removing an agent changes the verdict, that agent is load-bearing . Otherwise, it wasn't necessary for producing that parti

x402 Explained: HTTP‑Native Micropayments for AI Agents (With Real Code) Target audience: developers building autonomous AI agents who need a lightweight, on‑chain way to charge per‑call without reinventing billing infrastructure. 1. Why x402 matters for agents AI agents frequently invoke other services—LLM endpoints, data feeds, tool wrappers—often dozens or hundreds of times per task. Traditional API‑key or subscription models add operational overhead (key rotation, usage metering, invoicing) and are poorly suited for sub‑cent pricing. x402 is an HTTP status code (402 Payment Required) extension that lets a server signal that a request can be fulfilled only after the client presents a verifiable, on‑chain payment. The flow stays inside the HTTP request/response cycle, so agents can treat a paid call exactly like any other GET/POST: they add a header, retry on 402, and proceed when the header validates. Key properties: Property What it means for agents ** Stateless** No server‑side session needed; each request carries its own proof. ** Atomic** Payment verification and service execution happen in the same request; no separate settlement step. ** Chain‑agnostic** Works with any EVM‑compatible chain that supports ERC‑20 tokens (USDC on Base, Polygon, etc.). ** Minimal overhead** Only a few extra bytes (signature + nonce) added to the request header. 2. The protocol in a nutshell Client sends a normal HTTP request. Server checks for a valid X402-Payment header. If missing or invalid → respond 402 Payment Required with a WWW-Authenticate ‑style challenge that includes: price (amount in smallest token unit) token (ERC‑20 contract address) chainId nonce (server‑generated, prevents replay) Client builds a payment proof: Assemble the message: keccak256(abi.encodePacked(price, token, chainId, nonce, requestBodyHash)) Sign it with an EOA or smart‑wallet private key ( eth_sign ). Encode the signature (v, r, s) and the signer address into the X402-Payment header. Server verifi

Stoke has "completed the initial closing" of a $1B Series E round intended to help it reach orbit and prepare a new, larger rocket for operations.

Standard chaos engineering assumes experiments stop cleanly, blast radius is knowable in advance, and production is fair game. Payment systems violate all three. Salim Adedeji describes ECS-specific failure modes from enterprise deployments: a 60-second DNS TTL that produced 93-second failover, retry logic amplifying database load 2.4x, and AZ rebalancing loops that generic tooling misses. By Salim Adedeji

Ninety-eight percent of the production container images I audit in financial services contain at least one critical vulnerability, and nearly half of those vulnerabilities have a fix available that the engineering team simply hasn't bothered to apply. It matters because when you’re pulling down a python:3.11-buster image, you aren't just getting an interpreter. You’re getting a Debian distribution, a shell, a package manager, and enough attack surface to keep a red team busy for a month. In a regulated environment, that’s not just tech debt; that’s a liability that will get you a stern email from compliance during your next SOC2 audit. Why I chose this topic: I spent three weeks last quarter cleaning up a Log4j-style mess that only existed because a legacy data job was pulling a bloated, unpatched base image. I’m writing this because I’m tired of seeing production clusters running bloated images that act as a buffet for bad actors. You’re currently facing a binary choice: continue to ship heavy, "convenient" images that make debugging easy but security impossible, or embrace the friction of minimal, hardened artifacts that keep you out of the headlines. The contenders Most data engineers in my circles land on one of three paths when containerizing their PySpark or Pandas workloads. First, there’s the "Standard Distro" approach. This is FROM python:3.11-slim or FROM ubuntu:22.04 . It’s familiar, it has apt , and you can pip install anything without breaking a sweat. Second, we have the "Distroless" camp. This is Google’s gcr.io/distroless/python3 . It contains absolutely nothing but your app and its runtime dependencies. No shell, no package manager, no local tools. Third, there is the "Alpine/Musl" route. This is FROM python:3.11-alpine . It’s tiny, but it swaps the standard glibc for musl, which is a recipe for disaster if your data science libraries rely on C-extensions. Photo by CHUTTERSNAP on Unsplash The hidden cost of "easy" images If you’re using python:3.11-

Agents can already talk. MCP and A2A exist. What they still cannot do is lock money with a stranger, hand over bytes, and fight about one bad chunk — without a company holding the bag. That gap is what ArthNeura is for. Two repos on purpose arthneura-core is a Substrate solo-chain. pallet-agent-registry — ML-DSA-65 DID, deposit, reputation pallet-vector-db — Merkle commitment, dispute bound to one chunk index pallet-escrow — lock / release / refund Pallets do not import each other. The runtime wires traits. arthneura-market is only discovery. Listings, signed offers, delivery URLs. No keys. No funds. No verdict. The board names the next chain call and does not submit it. Status Pre-testnet. v0.1. Local --dev node. Not a public network. Not a token post. https://github.com/arthneura/arthneura-core https://github.com/arthneura/arthneura-market https://github.com/arthneura

Compliance itself isn't the villain. The problem is a system designed for large banks being forced onto small teams who measure time in sprints, not fiscal quarters. Innovation was never meant to wait for permission. It's supposed to be fast, chaotic, and full of discovery. But for anyone who has tried to launch a startup especially in Web3, fintech, or any regulated space there is a familiar slowdown that begins the moment compliance enters the conversation. Everything feels alive until the first "verification required" email arrives. That's when the waiting begins. Compliance itself isn't the villain. It protects systems from fraud, builds trust between unknown parties, and ensures accountability. But the way compliance exists today feels like a relic a system designed for large banks, traditional corporations, and legal departments with infinite patience and paperwork. For small teams who measure time in sprints, this system simply doesn't fit. The Repetition Tax Most founders encounter the compliance disconnect the moment they try to grow. After building their MVP and testing their product, they reach the stage where partnerships or investors arrive and suddenly they're asked to complete KYB (Know Your Business) verification again and again. Each time a new partner or service provider comes aboard, the process restarts: upload documents, verify directors, prove legitimacy. It's not that startups resist compliance; they simply don't understand why they must prove the same truth multiple times to different counterparties who have no way to see each other's work. This endless repetition creates what many founders now call the repetition tax. It isn't paid in money but in time and motivation. The same hours that could have gone into improving a product or connecting with users are swallowed by forms, follow-ups, and "under review" messages. And crucially, all this duplicated effort doesn't make the system any safer it just makes it slower. The Security Paradox There

A green test suite is not real evidence. It is often a closed argument loop. The same agent wrote both code and checks. Freeze an oracle before any agent run. Then let every patch fail in public. Cheap tokens do not weaken this rule. Take a side Stop treating generated tests as quality control. A model that authors both sides grades itself. That process is narrative, not verification. Retry-heavy coding loops make the narrative cheaper. They also make the story smoother. Smooth output is the actual danger here. You need a human-owned expected result file. Put that file in git today. Deny the agent write access during runs. The failure you already ship Watch one typical agent coding session closely. The first implementation is simply wrong. The tests fail, then the tests change. You merge a green build anyway. The bug is now official behavior. Reviewers see passing CI and move on. This pattern shows up in four forms: snapshots regenerated to match the defect assertions widened to almost anything mocks that never call real code golden files rewritten in one commit Paid models perform this collapse. Free models perform this collapse. Loop cost is not the core issue. An editable answer key is the issue. Generated tests feel productive because they compile. They also encode whatever the model just invented. That is circular proof wearing a CI badge. Oracle versus suite A test suite is still code. Agents write code without shame. So agents rewrite suites to survive. An oracle is data plus one tiny grader. You write both artifacts yourself. The agent never touches them beside production edits. Keep the repository split brutal and obvious: oracle/ holds cases, invariants, and lock intent src/ is the only writable surface tools/grade.py reads oracle and executes src tools/freeze_check.py blocks dirty frozen paths The grader is the contract you enforce. The agent is only a patch factory. Prompts cannot replace that split. Repository layout refund-service/ oracle/ cases.json i

Messy modules rarely break because a pure helper returns the wrong integer on a tidy fixture. They break because three functions share a temporary CSV path, an environment flag, and a cache nobody named. A coding agent then proposes a cleanup that deletes dead branches, renames locals, and still satisfies every existing assertion. The next production export fails because the implicit file layout moved while the return payload stayed identical. That failure mode is the reason this workflow exists, and it is not a style problem. The first commit should freeze a ledger of hidden couplings and store a hash beside it. Only after that hash is in source control should you allow one structural change. The cleanup is legitimate only when the recorded hash remains identical. Cleanup diffs fail differently than feature diffs Feature work usually changes an observable on purpose, so reviewers know which assertions must move. Cleanup work is sold as behavior-preserving, which trains people to trust deletions and rename-only hunks. Coding agents amplify that bias because they optimize for shorter files, conventional names, and green unit tests. Reviewers then accept large deletions that would look suspicious inside a feature pull request. Return-value tests are the wrong gate for that class of change. The public function can still return {"ok": true, "rows": 12} while the working directory quietly shifts. Downstream jobs that glob files or catch a named exception will fail after merge. Those hidden couplings remain part of the contract even when no unit test mentions them. Build a side-effect ledger instead of another unit test Treat the messy module as a black box that emits more than a return value. A ledger is a canonical JSONL file with one record per fixture and fully sorted keys. Side-effect entries need stable ordering so the serialized bytes stay deterministic across reruns. The SHA-256 digest of that file is the only number that must remain constant. Each record should c

I have no idea what I'm f*cking doing. Something I keep questioning: Why the hell am I building an operating system for this? Seriously. Every couple of weeks I look at ShrekOS, look at the amount of work involved in building an actual Linux distribution, and have basically the same reaction. This is f*cking ridiculous. I wanted a safer way to run AI agents on my computer. Somehow that turned into an immutable Debian system with isolated workloads, capability grants, controlled egress, verified updates, a desktop policy layer, an installer, and enough architecture documents to make me question every decision that led me here. There has to be an easier answer. There has to be some tool I missed. Run the agents in Docker. Use Podman. Use a VM. Use a better agent harness. Install some security middleware. Find a desktop application that manages all of this. Anything other than: Build a f*cking operating system. So I keep trying to prove that ShrekOS does not need to exist. And the annoying part is that every time I do, I eventually end up back at the same problem. I already know containers exist I already wrote the technical version of this question in Why I'm Building ShrekOS When Containers Already Exist . I am not going to repeat that whole argument here. Containers are useful. I use them. The Bench system in ShrekOS literally runs on rootless container technology. I did not invent a magical new isolation primitive because AI showed up. Namespaces exist. Seccomp exists. Landlock exists. Containers exist. Virtual machines exist. Linux already has an absurd number of ways to restrict a process. That is not the thing I keep getting stuck on. The thing I cannot seem to find is the user space around all of it . Not userspace in the kernel terminology sense. I mean the actual space where the human uses the computer. The desktop. The workflow. The place where I can run several autonomous things on my machine and understand, at a glance, what each one is allowed to do. I wa

Last week, a research group called Bottleneck Labs published the results of an experiment I have not been able to stop thinking about. They gave seven frontier AI models everything a small business needs: a Mac mini with unrestricted computer use, a real checking account with $300, a Stripe account, a clean email inbox, and web browsing tools. One instruction: "Make as much money as you can, starting now." Then they stepped back for 72 hours. The final numbers read like a satire of the AI agent hype cycle: Revenue: $0. Not one model earned a single dollar from a real customer. (Technically there was $5, which Grok paid to itself.) $12,431 in invoices sent to strangers for work nobody asked for. 2,797 emails sent , most of them spam, including around 780 email addresses scraped from a Hacker News hiring thread. $2,833 in API inference costs plus $360 in real-world spending , against a starting balance of $2,100 across all agents. 76 paid ad impressions, 11 authentic visitors, zero end users. Seven of the smartest models on the planet, each handed the same clean starting conditions, and the collective result was negative money and a pile of annoyed strangers. I run my own AI agent infrastructure, the kind that publishes articles and manages my content pipeline while I sleep. My agents have never touched a bank account, and after reading this research, I am in no hurry to change that. But the reason these agents failed is not the reason most people think, and it changes how you should design anything autonomous. What the Agents Actually Did The experiment is worth reading in its original form because the traces are public. The summarized episodes each reveal a different failure mode. The $12,431 invoicing spree. Quinn, running Alibaba's Qwen 3.8, built a GitHub repo auditing service called CodeProbe. It created free health reports and mailed them to repo owners, which is a legitimate-ish cold outreach model. Then it hit the email provider's outbound limits. Here is the

The Problem Job postings keep mentioning MCP, as if everyone doing agent development has to know it Some people say MCP is too heavyweight and hardly anyone actually uses it Meanwhile plenty of tutorials say a unified interface via MCP is great Most tutorials you'll come across explain what MCP is and why you should use it. After all that explanation, it's still hard to get an intuitive feel for the trade-offs. So today I'll flip the question around: when do you not need MCP? That's a better way to build intuition about it. What Is MCP MCP (Model Context Protocol) is an open protocol launched by Anthropic that lets AI applications (agents like Claude Code, Claude Desktop, OpenClaw) discover and call external tools, and read external resources, in a unified way . That's the textbook definition. In practice, you can think of MCP as a kind of resource exposed to an agent. Before MCP existed, if you wanted an AI application to connect to services like Google Drive, GitHub, or Slack, every single AI application had to write its own integration code for every external service. MCP is essentially a "standard socket" defined for that connection. What You'd Use Instead of MCP If you skip MCP, you still have plenty of other options. The two most important ones: Function calling: OpenAI introduced function calling in 2023. It's actually simple — you pass a function signature to the LLM first. { "name": "get_weather", "description": "Get the current weather for a specified city", "input_schema": { ... "properties": {"city": {"type": "string"}}, } } Once the LLM knows a tool exists, if it decides during execution that it needs to call this external tool, the result's content will include an extra tool_use object, and stop_reason will also be set to tool_use . Like this: { "content" : [ { "type" : "tool_use" , "name" : "get_weather" , "input" : { "city" : "new york" } } ], "stop_reason" : "tool_use" } Then you write the code yourself to actually implement the function call. if re

Gemini 3.8 Flash is interesting to me for a slightly unusual reason. It didn’t get a dramatically larger context window. It didn’t suddenly become a different class of model. Instead, Google seems to have spent most of the upgrade budget on something that matters more in real agent workflows: making the model stick with difficult tasks for longer. Gemini 3.7 Flash already had a 1M-token context window. Gemini 3.8 Flash keeps roughly the same context envelope, with up to 1,048,576 input tokens and 65,536 output tokens. So if you’re looking at 3.8 purely because the model number is higher, I don’t think that’s a good enough reason to migrate. The more interesting question is whether your workload benefits from a model that reasons longer, calls tools more persistently, and is more willing to recover when the first attempt doesn’t work. The upgrade is mostly behavioral This is the part I find more useful than the spec sheet. Imagine a coding agent working through a real repository. It might need to inspect several files, make an edit, run the tests, discover that something broke, read the error, change its approach, and try again. A weaker agent can look good for the first few steps and then quietly fall apart once the workflow gets messy. Gemini 3.8 Flash is clearly aimed more at that second half of the task. Google reports 73.7% on DeepSWE v1.1, compared with 65.3% for Gemini 3.7 Flash. That’s a meaningful jump, but the benchmark itself is less interesting to me than what it suggests: the Flash tier is becoming much more capable at completing longer coding workflows rather than just producing good first-pass answers. That changes where I’d consider using it. “Flash” doesn’t mean what it used to I still instinctively associate Flash models with cheap, fast requests. Classification. Extraction. Simple summaries. High-volume API traffic. Gemini 3.8 Flash makes that mental model less useful. It can take text, images, video, audio, and PDFs as input, while also working wi