标签：#AI

JBL's new speaker/light hybrid will cost $330.

Soundcore's latest projector is bright enough to use in daylight with the shades up.

Consumer AI apps need to stop making users learn their product architecture.

Was Greg Brockman the right executive all along?

The AI that powers Gboard's Rambler is coming to more Google products, including Chrome.

The AI giant acknowledges that it could have done far more to prevent its AI agents from going rogue. But it still fails to explain why it didn't see this fiasco coming.

The report, which spans several discrete cybersecurity compromises, is the most complete accounting of the incident to date.

An agent patch that passes its own tests is a baseline, not a verdict. The same model wrote the code and the tests, so both share the same blind spots. Mutation testing scores the tests themselves: inject a fault, run the suite, and see whether it notices. In practice, the first mutant often survives. Previous rounds on this account established three gates before merge: property checks, fixtures, and a freeze on flaky tests. This round adds a fourth gate that runs after the suite is green. It answers a different question — not "does the patch work?" but "would the tests catch it if it didn't?" Why green tests from an agent are weak evidence Code coverage measures execution, not detection. A test can execute a line and still miss the bug on it. A suite that only checks is_even(2) and is_even(4) runs both lines, passes both assertions, and stays blind to a mutation that flips == to != . Agents produce this shape of test by default. They follow the happy path, mirror the implementation, and rarely probe boundaries. The result is a suite that is green, fast, and weak for regression. Mutation testing converts that intuition into a number. For each small fault, rebuild and rerun. If the tests fail, the mutant is killed. If they pass, it survived — and you found a hole in the suite, not in the code. A minimal harness The harness below applies one mutation at a time to the implementation file, compiles it together with an unchanged test file, runs the resulting binary, and records the outcome. It is deliberately small: regex-based, two files, no dependencies beyond a compiler. #!/usr/bin/env python3 # mutate.py — score a test binary against source mutations. import re import subprocess import sys import tempfile from pathlib import Path MUTATIONS = [ ( " eq_to_neq " , r " == " , " != " ), ( " lt_to_le " , r " < " , " <= " ), ( " add_to_sub " , r " \+ " , " - " ), ( " zero_to_one " , r " return 0; " , " return 1; " ), ] def mutate_once ( src : str , pattern : str , replaceme

The most common documentation failure is not a weak prompt or a lazy writer; it is the absence of a clear boundary between machine-draftable content and human-owned claims. A pipeline that drafts reference sections with free-tier model access and then verifies them with a symbol drift check turns docs into a testable artifact instead of a trust exercise. The model writes the inventory, and the human owns the promises. Why documentation rots inside a healthy CI pipeline Documentation bugs share a distinctive property: they are usually discovered by the people who consume the API, not by the pipeline that builds it. A function renamed in the last refactor stays documented under its old name until a user files an issue, and a newly added flag never appears in the docs at all. The root cause is structural, because nothing in the merge pipeline compares the documented surface against the actual code surface. A prompt cannot know what changed inside a pull request, so the fix has to live in the pipeline around the model. The workflow drafts reference material, validates that every documented symbol still exists, and routes the remaining claims to a human reviewer. That division of labor is the entire design, and each step has a concrete tool. The ownership boundary: what a model may draft The first step is to separate documentation into two classes by asking a single question: can this statement be verified against the codebase alone? If the answer is yes, a model may draft it, and if the answer is no, a human must own it. The table below applies that test to the statement types that appear in most API docs. The model may draft A human must own Function and class inventories Behavioral guarantees CLI flags and their defaults Security and authentication properties Config keys and their types Compatibility and support promises Error codes and exit statuses Deprecation timelines Compilable usage examples Performance or cost claims Parameter descriptions from signatures Ratio

Google Cloud has introduced Gemini Enterprise Agent Platform , a developer platform intended to bring AI agent creation, deployment, runtime operations and governance into one product surface. The April 23, 2026 announcement marks a broader shift in how Google is positioning Gemini for business use: not simply as a model that answers prompts, but as part of a stack for building long-running agents that can carry out defined work across company systems. According to Google Cloud's announcement of Gemini Enterprise Agent Platform , the Agent Platform evolves the services previously associated with Vertex AI into a unified platform. It combines model access, agent development tools, runtime infrastructure and operational controls. Google is also extending the broader Gemini ecosystem through Gemini API previews, Google AI Studio, Antigravity, Android development support, the Gemini app on macOS, Gboard features on Android, and planned Gemini Enterprise for Customer Experience capabilities. The important distinction is that Google is describing a platform for agents that can persist over time, retain relevant context and interact with tools, rather than a collection of isolated chatbot features. For companies exploring automation, that could make it easier to move from one-off AI experiments toward applications designed around repeatable workflows. It does not, however, remove the need to define reliable processes, permissions and human oversight before deploying an agent in a customer or operational workflow. What Gemini Enterprise Agent Platform brings together Google describes the Agent Platform as the runtime and governance layer for production-scale AI agents. It is built around three connected areas: creating agents, running them with context and tools, and observing or controlling their behavior once deployed. Agent Studio provides a low-code interface for building agents. Developers can also use the upgraded Agent Development Kit (ADK) , while the reworked Agent

Claude Code is amazing. It feels like cheating in the best way until it doesn't. The first time I dropped a vague comment and it gave me a fully working component, I was hooked. But somewhere along the way, I realized something weird was happening: I was coding less... and thinking less. Let’s talk about that. The Tools Got Better, But We Got Lazier In 2022, you still had to know stuff . Now? You just prompt your way through half the job. And sure, productivity skyrocketed. Ship faster, write fewer tests, scaffold full APIs in a couple of minutes. But here’s the tradeoff no one likes to talk about: we’re outsourcing thinking . Not tasks. Not code. Thinking. I've seen teammates slowly stop debugging on their own. They just throw the stack trace into Claude. I’ve seen people stop learning the fundamentals of async behavior or memory handling because “Claude will tell me.” Cool. Until Claude gives you a bad answer and you don’t realize it because you stopped building your intuition. The Industry’s Not the Same The layoffs? Brutal. And the worst part isn’t just losing a job it’s realizing you didn’t build portable skills . Because if Claude wrote all your code at your last job, what exactly did you learn? When companies trimmed down, they didn’t just cut bodies. They cut noise. They kept the people who could solve problems , not the ones who could Google fast or write perfect prompts. So ask yourself: if Claude disappeared tomorrow, could you still contribute? Using AI ≠ Being a Great Engineer I’m not anti-AI. I use Claude. I use Cursor. I use Copilot. But I don’t depend on them. There’s a difference between boosting productivity and becoming a prompt monkey. The first one makes you valuable. The second one… doesn’t. Let’s get real: code was never the point. It was always about solving problems, navigating ambiguity, simplifying complex systems, designing clean architecture. None of that goes away with AI. In fact, it becomes more important. The Skills You’ll Regret Not

Flipboard is acquiring Bluesky feed-building startup Graze, bringing its privacy-friendly ad technology and creator monetization tools into Flipboard’s growing open social web ecosystem.

We keep timelines for a living — rail telemetry, grid filings, catalog censuses. Most weeks the entries don't talk to each other. Then came the twelve days between August 14 and August 26 , when a federal banking regulator, the world's largest cloud, the White House, a corporate spend platform, a $4 billion stablecoin, an anonymous transaction flood, and the Texas grid operator all moved — separately, but in the same direction. We're not going to tell you what it means, because we don't know yet. What we can do is what any good case file does: lay the exhibits on the table, show you the strings, and write the hypothesis down in pencil. The exhibits Aug 14 — The OCC grants conditional approval to World Liberty Trust Company : the presidential family's stablecoin operation gets a path to a federal banking charter. Aug 16 onward — The x402 rail's transaction count detonates: 4–6× baseline for a week, then an all-time record 1.17M settled payments in one 15-hour window at three cents a payment, dollar volume flat. Industrial machine buyers, stress-testing rails in production. Aug 18 — AWS makes Bedrock AgentCore Payments generally available : production agents can autonomously discover and pay x402 endpoints, with a curated Coinbase bazaar in the console. Same day, federal regulators unveil new crypto rules. Aug 19 — Trump hosts the CEOs of Coinbase, Ripple, Kraken, Robinhood, and ICE at the White House , SEC Chair in the room, pressing Congress to pass the CLARITY Act. Aug 20 — Ramp switches on agent wallets for 70,000+ businesses: corporate treasuries funding AI agents that spend USDC on Solana. Aug 25 — World Liberty's $4.05B USD1 goes native on the Canton Network — the institutional chain Wall Street banks use for tokenized settlement. Aug 26 — ERCOT confirms it will audit ~300 proposed data centers and pause new approvals : the physical layer gets told prove you're real before you plug in . And the scheduled exhibits: Sept 15 — Cloudflare's default wall against mix

Link to the Source Code As a data engineer, I spend my days designing clean, optimized data structures. But at home, I face a much tougher crowd: my family. We manage our shared finances together to optimize our budget, and because of where we live and work, we have to do this in several different currencies (like USD, EUR, CZK, and UAH) Like any developer, I first tried to find a ready-made app to solve this. But I ran into a classic problem: they were either bloated with a million features we didn’t care about, or they were missing the exact features we actually needed. So, we did what any desperate family does: we opened a Google Sheet . We tracked our money there for a while, not because it was perfect, but because it helped us figure out what we actually needed from a real application. It was our "living schema design" before I wrote a single line of code. In this article, I want to show you how I looked at this problem from two sides—as a frustrated user who just wants to log expenses, and as a data engineer obsessed with clean database design. Here is the story of how I built our custom home accounting server. Part 1: Django, a Star Schema, and the Framework Battle By 2025, I was ready to replace our Google Sheet. My main programming language is Python, so I had three realistic choices: FastAPI, Flask, or Django. FastAPI is the cool kid on the block for high-speed APIs, but we didn’t expect millions of requests (unless my family suddenly grew by a factor of a million). We also needed a friendly web UI, which FastAPI isn't naturally built for. I had just used Flask for my previous project, but I wanted to challenge myself and learn something new. Django felt like an old friend I hadn't seen in years. It has amazing built-in tools (like the admin panel and great translation support), and using it was the perfect way to refresh my skills and grow as a developer. The Database: Why a "Star Schema" Actually Makes Sense As a data engineer, I didn’t want a messy data

The problem with Meta's AI restructuring plan is the AI wasn't good enough.

Google says Gemini 3.5 Transcribe will soon let you use speech-to-text in any web field in Chrome.

Google has updated Gemini Audio with new transcription capabilities that automatically detect specialized jargon and more than 85 languages. Gemini 3.5 Transcribe is a new addition to the Gemini family that follows the launch of 3.5 Live Translate, and comes as we're still waiting for Google to release the Gemini 3.5 Pro model that it […]

For the past week, developers have been puzzling over a model called Ox Alpha. It appeared on OpenCode and OpenRouter on August 20 with no owner attached, free to use, with a 1M-token context window and support for image and video input. Independent researchers fingerprinted its tokenizer, ran compression analyses, and traced it to Z.ai's GLM family with high confidence. On August 26, Z.ai confirmed it: Ox Alpha was GLM-5.3-Flash in disguise, tested anonymously to gather real-world feedback before the official launch. The reveal matters beyond the detective story. GLM-5.3-Flash is the first natively multimodal model in the GLM-5 series, it ships with open weights under the MIT license, and Z.ai claims it delivers frontier-adjacent performance at roughly one-tenth the price of its predecessor. A few things upfront. All benchmark numbers below are vendor-published. I have not run GLM-5.3-Flash myself, and the comparison tables skip some strong models (no Opus 5, no Grok 4.6, no Fable 5). Treat the scores as Z.ai's claims, not independent verification. What the Model Actually Is GLM-5.3-Flash is a Mixture-of-Experts model with 320B total parameters and just 18B active per token. The context window is 1M tokens. Unlike GLM-5.2 and GLM-5.3, which were text-only and drew repeated complaints about it, this model accepts text, images, and video natively, at the architecture level rather than as a bolted-on vision module. The parameter math is the interesting part. Compared with the GLM-4.5 series, GLM-5.3-Flash has a similar total size (320B vs 355B) but nearly halves the activated parameters (18B vs 32B) and the layer count (45 vs 92). In other words, Z.ai deliberately traded depth and width for a shape that is cheap to serve, then compensated with a richer training recipe: a 30T-token multimodal pre-training corpus and what the company calls Manifold-Constrained Hyper-Connections to improve scaling efficiency. A Hybrid Attention Architecture The most technically significa

Every extraction pipeline I have ever pointed at a language model shares the same dirty secret: the JSON comes back almost valid. Almost is where the bugs live, because almost passes your eyes and then fails your schema at midnight. So I built a loop where the model grades its own homework, then let it run for 48 hours on a free server to see what breaks. The experiment The idea was simple: take plain-text payloads that look like webhook bodies, extract five fields against a small schema, and give the model exactly one chance to fix its own mistakes. I wrote the rules down before writing any code, because rules written after a failure are just excuses. Pass one asks the model to return the fields as JSON. A validator checks the result against the schema. If validation fails, pass two sends the original payload, the bad JSON, and the exact validation errors back to the model. Every attempt, raw text included, lands in a JSONL log. I ran that loop for 48 hours on MonkeyCode's free server option, using its free model access for both passes. Disclosure: This article was prepared as part of MonkeyCode's product outreach. Here is the loop, trimmed to the parts that mattered. import hashlib import json import time from datetime import datetime , timezone import jsonschema import requests SCHEMA = { " type " : " object " , " required " : [ " event " , " customer_id " , " amount " , " currency " ], " properties " : { " event " : { " type " : " string " , " enum " : [ " charge.succeeded " , " charge.failed " ]}, " customer_id " : { " type " : " string " , " pattern " : " ^cus_ " }, " amount " : { " type " : " integer " , " minimum " : 0 }, " currency " : { " type " : " string " , " minLength " : 3 , " maxLength " : 3 }, }, } SEEN : set [ str ] = set () def now_iso () -> str : return datetime . now ( timezone . utc ). isoformat () def call_model ( prompt : str ) -> str : # Point this at the free model endpoint you are testing. resp = requests . post ( " https://your-endpoint.e

The agent patch passed the gates I ran on it. Its unit tests were green, fixtures matched, nothing was flaky. Then I seeded four faults into the implementation, one at a time. Two survived. That gap is what this article is about. A green suite is a claim, not a measurement. Mutation testing turns it into a measurement: introduce a fault, run the suite, and see whether the suite notices. I now run this loop before merging any agent-written patch, and the whole thing costs a few rebuilds. Why green tests lie A passing test proves one thing only: the test and the implementation agree on the inputs the test exercised. When an agent writes both the patch and the tests, the tests inherit the patch's assumptions. If the implementation encodes a wrong assumption, the test encodes the same one. The suite is green because it is blind, not because the code is right. The patch in this article came from a free model on MonkeyCode's free model access. Disclosure: This article was prepared as part of MonkeyCode's product outreach. The model wrote a bounded queue and a test file. The test file was not wrong. It was blind in exactly the place the implementation was wrong. The method: five steps Mutation testing is easy to describe and awkward to skip: Freeze flaky tests first. A flaky test fails at random, so it makes every mutation look like a kill. The signal is garbage. This is the flaky freeze from the gates post; without it, the numbers mean nothing. Select the functions the patch touched. Mutating untouched code measures someone else's tests. Generate mutations. Each mutation is one small fault: drop a modulo, flip a comparison, change an increment. Run the suite against each mutation. Rebuild, run, record. Gate on the kill rate. A surviving mutation means the suite cannot detect that fault class. Send the patch back with the survivor list as evidence. The artifact A minimal bounded queue, the agent's test, and a small Python driver. The queue: // bounded_queue.h #pragma once