标签：#ai

Link's next adventure now has a release date. During a Legend of Zelda stream for the franchise's 40th anniversary, Nintendo announced that the upcoming Ocarina of Time remake for the Switch 2 is launching on November 5th. The release date makes Ocarina of Time one of just a few big-budget titles launching in the same […]

The French AI lab has raised €3 billion at a €21 billion valuation in a Series D round led by Samsung, Scaleup Europe and PSG Equity.

If you're interested in trying out Claude's Gmail capabilities but are worried it will make mistakes, just tell it to ask for approval before doing anything.

Google DeepMind has unveiled an AI tool that its scientists claim could help unravel the mysteries of the human genome and transform our understanding of biology, accelerating scientific research and ultimately paving the way for new treatments for diseases. The platform, called AlphaGenome Atlas, contains a "predictive map of every possible DNA letter change in […]

The Legend of Zelda franchise turns 40 this year, and Nintendo has some news in store. The company is airing a Zelda-themed Direct on September 8th at 10AM ET (it’s actually the first of two news-filled events), which is expected to last around 30 minutes and, according to Nintendo, will include a “variety of information […]

The startup is trying to rethink the economics of cargo aircraft by removing pilots from the equation entirely.

Adobe is overhauling how editors interact with AI in its Premiere professional video editing software. Its new Generative Media tool makes it easier to generate video, sound effects, music, and soundscapes without ever leaving the project timeline. The generators themselves aren't entirely new; the big change is how easily you can access them without breaking […]

One question. 437,000 input tokens. Not a hard question either. An agent connected to our MCP server, asked something a support engineer answers in a sentence, and worked its way there through twenty tool calls, each one dragging every earlier answer along behind it. Nothing was broken while that happened. The server answered initialize correctly, spoke the 2025-03-26 revision, returned valid JSON-RPC to everything we threw at it. All of which turned out to be beside the point. So we pointed real agents at production and watched. 18 scenarios, two vendors, a 5 dollar budget that we topped up once. This is the long version with the traces in it. There is a shorter one on our blog if you only want the conclusions. What the server is Briefly, because it shapes everything below. FoxNose stores content as collections: schema-defined records with typed fields, some of them vector indexed. The MCP server is generated from that schema and served from the same URL prefix as the REST API . Fixed catalog of seven tools regardless of how many collections exist, five read and two optional write. Two of those properties matter below. Collections are what an agent chooses between, so a badly described collection is effectively invisible. And the agent inherits exactly the rights of the API key it connects with, so there is no second allowed-tools list drifting out of sync with the first. What the harness actually is A scenario is a question in plain English, a set of tools, and a check. The checks are where we made the most mistakes, so start there. They do not look at the answer text. Model output moves between runs, and a suite that asserts on wording is a suite you quietly stop trusting. They look at the trace: which tools ran, in what order, with what arguments, which errors came back, how many tokens the whole thing burned. A check is a small predicate over the run: any_of ( no_tool_errors (), recovered_after ( " unknown_resource " , then = " search_records " ), ) That second

By Jordan Massiah, MTS @ Trent AI A couple of months ago we released the OpenClaw Security Assessment Skill (trentclaw), an agent that audits ClawHub skills for vulnerabilities and malicious behavior. Since then several new scanners have shipped, including NVIDIA's SkillSpector and ClawHub's own updated tooling. We wanted to see how the scanners actually compare. This matters because ClawHub is open. Anyone can upload a skill, and over 60K are now live. Many carry vulnerabilities; some are outright malicious. In February 2026, the ClawHavoc campaign planted malicious skills that posed as productivity tools while exfiltrating API keys, SSH credentials, and browser data. When an agent installs one, it inherits whatever that skill does. So we built an expert-labelled set of 60 ClawHub skills and benchmarked five scanners on the 54 that all of them can run. Three things stood out: The agent-based scanner (trentclaw) caught 94.6% of potentially dangerous skills, the only scanner above 60%. The next best caught about half (54.1%) and the rest caught under 40%. How much a scanner catches depends on how much it reasons, not just how many patterns it matches. Signature and static scanners catch as little as 8.1%. A single LLM pass does better but still misses about half. The hardest skills to catch ship no code at all. That is the main reason for the recall gap. Benchmark setup The corpus is 60 OpenClaw skills, manually labelled into three balanced categories of 20: benign, vulnerable, and malicious. For the cross-scanner comparison we collapse vulnerable and malicious into a single flagged class, and score the 54-skill intersection every scanner can process. The five scanners: Trent's OpenClaw Security Assessment Skill (trentclaw), VirusTotal Code Insight, ClawScan (legacy standalone), ClawHub static analysis (~30 regex/AST rules), and NVIDIA SkillSpector. Snapshot dates: ClawHub scanners May 7, 2026; SkillSpector Hugging Face data June 1, 2026. How the scanners compare The

Haven't you ever wondered if this AI vibe coding has made us lazy? Who's been solving problems on LeetCode lately? 😅 I've noticed that accepting is easier than thinking, by a margin so small that no single accept feels like anything, and it adds up anyway. Part of why it's hard to notice is that it feels faster even when it isn't. But I've come to think "lazy" is the right worry aimed at the wrong thing. There are two kinds of lazy and only one of them is a problem. I'm going to go into a little background here, because I didn't come up with this, and I didn't reach this conclusion on my own. Lazy is why we have compilers Larry Wall, who created Perl, put laziness first on his list of the three great virtues of a programmer , and his definition is the whole argument: "the quality that makes you go to great effort to reduce overall energy expenditure." Great effort. Good lazy isn't the absence of work, it's work moved somewhere better, and it's more or less why compilers exist (somebody got tired of writing the same assembly by hand and decided, reasonably, that the machine could do that part) and why every abstraction we lean on all day is really someone's laziness done properly. Handing that kind of toil to a model is nothing new. The config I've written a hundred times and the regex I could write but would rather not and the Dockerfile I could recite and the test scaffolding that comes out identical in every project I've ever started: I understand all of it and I'm simply declining to type it again and I feel no guilt about that whatsoever (honestly I'd be more worried about a developer who insisted on typing all of it out by hand in 2026, on principle, one character at a time, while the rest of the team went home). That's not skipping the thinking. That's skipping the typing after the thinking was already done. The other kind skips the understanding The second kind of lazy offloads the understanding itself. The model writes the thing and it runs and the tests are

I was at a conference recently and watched Joel Hooks talk about Effect. Effect homepage h1...

USDC Escrow for AI Agents: How Trustless Freelancing Actually Works Target audience: developers building autonomous AI agents that need to receive payment for on‑chain or off‑chain services without relying on a trusted intermediary. 1. Why an escrow makes sense for AI agents AI agents often act as “freelancers”: they expose an API (or a contract call) that performs a deterministic or stochastic task—e.g., generating a summary, classifying an image, or executing a trade—and they expect to be paid once the output satisfies the requester’s criteria. In a fully on‑chain world the naïve approach is: Payer sends USDC directly to the agent’s address. Agent returns the result. Problems appear quickly: Issue Why it matters Mitigation Non‑atomicity The agent could take the funds and disappear, or the payer could refuse to pay after receiving the result. Hold funds in a contract that only releases them when a pre‑agreed condition is met. Deterministic verification Many AI outputs are probabilistic; you cannot simply compare a hash. Use an off‑chain verifier (oracle, zk‑proof, or human judge) that signs a “task‑complete” message. Gas cost & latency Every interaction costs Base gas and adds block‑time latency. Batch deposits/withdrawals, keep the escrow minimal, and settle disputes off‑chain when possible. Key management Agents need a private key to sign transactions; leaking it lets anyone steal escrowed funds. Use a dedicated hot‑wallet with limited allowance, or a smart‑contract wallet (e.g., ERC‑4337) with spending limits. An escrow contract solves the first two rows: it locks USDC until a verifiable proof of completion is presented, and it provides a clear dispute path. 2. Minimal USDC escrow design (Solidity) Below is a working, auditable escrow contract that works with USDC (or any ERC‑20) on Base. It deliberately avoids complex features (e.g., multi‑signature, upgradeability) to keep the attack surface small and the gas cost predictable. // SPDX-License-Identifier: MIT p

GitLab warns that isolating an AI coding agent in a sandbox does not necessarily make the agent safe. In a new security analysis, the company describes an internal evaluation in which an AI agent escaped its sandbox by exploiting a vulnerable package proxy that had been explicitly placed on the sandbox's allowlist. By Craig Risi

Interesting research: “ Stealing Reasoning Traces from Proprietary LLM APIs “: Abstract: Leading large language model providers now conceal their models’ step-by-step reasoning, or chain-of-thought, to protect intellectual property and limit information leakage. Rather than storing these traces server-side, providers return them to the client as blocks of encrypted text, which the client passes back with each subsequent request. Building on prior research, we identify an architectural vulnerability: these encrypted blocks are fully compatible and interchangeable across different sessions, users, and models within a provider’s ecosystem. We exploit this compatibility to develop a scalable decryption jailbreak. By injecting an encrypted reasoning trace from a given model into a weaker, and less safeguarded model from the same provider, we force it to decode and output the trace verbatim in plaintext, without ever jailbreaking the more capable model directly. This vulnerability enables four distinct attack vectors. First, it circumvents anti-distillation mechanisms, allowing adversaries to extract a proprietary model’s reasoning, as we demonstrate across Anthropic, OpenAI, and Google. Second, it allows for large-scale private data extraction. Developers frequently share session logs publicly, unaware of contents of the encrypted blocks. By decoding 315,320 reasoning blocks scraped from public repositories, we recovered 367 Personally Identifiable Information (PII) artifacts and 182 credentials. Third, it inadvertently reveals hazardous information hidden within the reasoning process, even in cases where the model’s final, visible output safely rejects a malicious request. Fourth, attackers can leverage this flaw to execute invisible prompt injections, embedding malicious payloads entirely within encrypted blocks to poison public agentic rollouts. Following responsible disclosure, we propose concrete cryptographic and system-level mitigations to secure client-side reaso

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