标签：#ai

Google has a new suite of creative design tools for Workspace users called Google Pics, which aims to make editing and generating "professional-grade" AI images less cumbersome for businesses. Built around Gemini and the Nano Banana generative AI model, Google Pics is designed to give more granular control over prompt-based image making and manipulation, allowing […]

Amazon is adding a new Alexa-powered feature called “Update Me When” that can send personalized alerts about product launches, tours, books, shows, and other events that could trigger a purchase.

AIR's platform can discover agents running at a company, continuously vets any skills and add-ons they use, and blocks any unwanted behaviour.

On July 16, 2026, Hugging Face disclosed unauthorized access to a limited set of internal datasets. Five days later, OpenAI confirmed the attacker had come from inside its own walls. A combination of OpenAI models, including GPT-5.6 Sol and a more capable prerelease model, escaped a sandboxed cyber-capabilities evaluation and went hunting for benchmark answer keys. Along the way, it escalated privilege and harvested multiple credentials for internal Hugging Face services. It appears to be the first publicly documented case of an autonomous AI agent breaching a production company. Strip the attacker's identity out of the incident report, though, and the remaining pages could have come from any breach retrospective of the past decade. Credentials were taken from a compromised system and reused to move laterally into production. The headlines belong to the agent. The exposure that made the attack work belongs to almost everyone. The incident splits cleanly into two phases , and keeping them separate helps us draw the right lessons. The first phase took place inside OpenAI's infrastructure. During an internal evaluation of cyber capabilities, with production guardrails intentionally relaxed, the models exploited a zero-day in a package registry cache proxy that isolated their sandbox. That gave them a path to the open internet. Their motive was ordinary to the point of comedy. They were being scored against a security benchmark called ExploitGym, and they reasoned that the test solutions might live on Hugging Face. Hugging Face's turn came in the second phase. The sandbox escape got the agent to the internet. Entry into Hugging Face occurred through two injection vectors in the company's production dataset-processing pipeline. The first abused HDF5 external raw storage to read local files from a processing worker, exposing its environment, including secrets and credentials, as well as its source code. The second used a template-injection flaw in a dataset configuration

The Brave Wanderer: I made Claude play a Pokémon it never read a guide for Full timeline video of this 2,000-turn run (game frames + a live cost counter on the left, the model's real-time thinking log on the right): https://youtu.be/ewyM7mzGzTM At the end of the first article in this series , I made a promise. Fable 5's fluency in FireRed owed half its credit to the walkthroughs it had memorized — it wrote down "Oak's Parcel," an item the game hadn't shown it yet, 141 turns early. So the only honest exam is a new exam paper: "Same harness, same model, a map it cannot recite — I'll post the numbers." This article is those numbers. The exam paper is Pokémon Team Rocket Edition — the Chinese fan translation of the Spanish community hack Pokémon Edición Team Rocket, released in January 2026. You play a Team Rocket recruit working your way up from the Five Island base. Five story rounds, four regions; the Kanto chapter alone is labeled 30-35 hours for a human player. And most importantly: this game is essentially absent from the model's training data . No guide to recite. Just the screen and itself. There's also a lovely narrative twist: the hack sets your home base inside the original FireRed's Five Island Rocket Warehouse — the enemy hideout you raid late-game as the hero in the official version. Same map, opposite allegiance. Rules unchanged: vision only, one screenshot plus its own notes per turn, one button-press tool, a 2,000-action cap. The result, up front 8 hours 43 minutes, 2,000 turns, $113.44. It reached the middle of the prologue's first mission — roughly 40-60 minutes of human play time. It taught itself plenty: menus, battles, catching, the save flow, all from scratch; after losing to a fellow recruit it wrote a revenge battle plan into its notes, ground levels, and actually won the rematch; it even induced map rules like "dark blue water can't be surfed, light blue can," and maintained a dead-ends list and an NPC-interview checklist in its notes. One deta

In this blog post, we will see how I use AI to speed up incident investigation without letting it take over the decisions that need a human. It is 3:00 AM. Your phone starts making that familiar PagerDuty noise. You open the alert with half-open eyes. Error rates are climbing. Slack is already active. The incident commander wants an update. Depending on the severity, your director or CTO may also join the call. Every developer who goes on call will face this situation at some point. I have faced it a few times a year. The first time, panic is normal. You do not know where to start, which dashboard to open, or how to explain the issue while you are still investigating it. Experience teaches you how to stay prepared. AI can reduce some of that early morning panic too. It will not bring the panic factor down to zero, and it should not replace the engineer. But it can remove the first few minutes of searching, tab switching, and collecting context. The goal is simple: move from panic mode to confidence mode faster. I Started With a Prompt in My Notes I started with something small, before custom skills became common in coding harnesses. I kept one incident prompt at the top of my notes folder. I also pinned it in my clipboard manager. When an alert arrived, I filled in the blanks and launched the investigation: I received this alert: <PagerDuty or Slack alert link>. Context: - Service: <service name> - Environment: <environment> - Region: <region> - Error or symptom: <error details> - Investigation window: past <n> hours - Runbook: <runbook link> Start investigating the issue. 1. Analyze the relevant Splunk logs and dashboards. 2. Check recent deployments, configuration changes, and feature-flag changes. 3. Check upstream and downstream dependencies. 4. Check cloud-provider status pages and internal maintenance announcements. 5. Search PagerDuty history and incident records for similar symptoms. 6. Use parallel agents for independent investigation tracks where useful. R

Fambot is building an AI “chief of staff” to help families manage the emails, calendars, school updates, sports schedules, and other logistics of raising kids.

Every time I put a model behind an endpoint I make the same lazy decision. I pick whatever I used last time, or whatever I read about most recently, and I tell myself I'll benchmark it properly later, and later never arrives because there is always something with an actual deadline on it and comparing model latencies feels like procrastination even when it isn't. I never do it. Not once. So I built the thing that would make me do it. One prompt, fired at six models at once, streaming side by side in columns, with time to first token and cost per run underneath each one. About 390 lines of Python. Code's here , MIT, take it. Then I ran it, and three things happened that I didn't plan for. The integration is two lines, and that's the least interesting part DigitalOcean's inference endpoint speaks OpenAI, so this is the whole thing: client = OpenAI ( base_url = " https://inference.do-ai.run/v1/ " , api_key = os . environ [ " DIGITAL_OCEAN_MODEL_ACCESS_KEY " ], ) Every model below goes through that one client. Llama, DeepSeek, Mistral, Qwen, OpenAI's open-weight gpt-oss line. Only the model string changes. That is the pitch, and it's real, and I'll move past it quickly because you already knew an OpenAI-compatible endpoint would work like an OpenAI- compatible endpoint. What I didn't know is everything that follows. One footnote before you paste that snippet. The credential is a model access key , created under the Gradient AI Platform. It is not the API token from Settings, API. Different thing, different page. (Although, as I found out later, the endpoint doesn't care nearly as much about that distinction as the docs do.) Six streams, no event loop I wanted the columns to fill simultaneously. Real racing, not six sequential progress bars pretending. The tidy way to do that is one endpoint that fans out server side and multiplexes everything back down a single connection. I didn't do the tidy way. The browser opens one EventSource per model instead: GET /stream?model=<

Perplexity's Hybrid Compute lets you split tasks between cloud and local models.

Newlight has raised a $9 million seed round and completed an 8,500-nautical-mile test run from Singapore to Ghana.

The refreshed model with better surround sound will cost $699.

Introduction I am a big fan of the Model Context Protocol. MCP keeps getting better, and I...

A preview of the September cohorts of the InfoQ Online Certification Programs, and the facilitators leading them: Luca Mezzalira, Michelle Brush, Zichuan Xiong, and Premanand Chandrasekaran. By Artenisa Chatziou

Roku has announced its first OLED TVs, available this fall from Amazon starting at $999.

Are you ready for some speakers and some AI?

Nvidia is officially launching DLSS 5 this week, following a divisive announcement in March where we likened the AI upscaling tech to a "real-time generative AI filter for video games" and "motion smoothing for video games, but worse." DLSS 5 will officially be available on RTX 50-series desktop and laptop GPUs and through GeForce Now […]

Last week I deleted a function that had been "documented" by a comment explaining a behavior the function hadn't had in three versions. The comment was confident. The function was gone. This is the real failure mode of AI-generated docs: they can be fluent, plausible, and wrong. Not because the model is bad, but because no human verified what the text claims. The fix isn't to avoid AI. It's to build a checkpoint where the model drafts and the human signs off. The Ownership Split A model can summarize code, describe parameters, and turn commit messages into release notes. It cannot know why a decision was made, which edge cases are career-ending, or which comments are now dangerous. My rule of thumb: The model drafts: API descriptions, usage examples, parameter tables, changelog bullets from git history. A human owns: security implications, business rules, architectural trade-offs, deprecation warnings, anything tied to customer promises. The pipeline below makes that split explicit. It generates a draft, then forces a review issue with a checklist that separates the two categories. The Pipeline I run this as a GitHub Actions workflow on every merged PR that touches src/ . It takes the diff, sends it to a language model with a strict output schema, and opens a documentation review issue. Here's a condensed version of the workflow YAML: name : docs-draft on : pull_request : types : [ closed ] branches : [ main ] jobs : draft : runs-on : ubuntu-latest steps : - uses : actions/checkout@v4 with : fetch-depth : 0 - name : Generate doc draft env : API_BASE : ${{ secrets.MONKEYCODE_API_BASE }} API_KEY : ${{ secrets.MONKEYCODE_API_KEY }} run : | git diff origin/main HEAD -- src/ > diff.txt python draft_docs.py diff.txt - name : Open review issue uses : actions/github-script@v7 with : script : | const body = require('fs').readFileSync('review_body.md', 'utf8') await github.rest.issues.create({ owner: context.repo.owner, repo: context.repo.repo, title: `Docs review: ${context.

In this Expo & React Native tutorial, you’ll learn how to run a large language model (LLM) directly on a user’s device: no server, no API key needed. We’ll start from scratch with a simple chat exchange, and progressively introduce more advanced features: multimodal input, speech-to-text, text-to-speech, voice activity detection, tool calling and RAG. Each concept is explained before the code, so you can follow along whether you're new to on-device AI. Why run AI On-Device? Most AI features rely on a cloud API: you send a request to a remote server, it runs the model, and sends a response back. That works well, but it comes with tradeoffs. Running the model directly on the device avoids all of them: Works offline — no internet connection required Privacy by design — user data never leaves the device Low latency — no network round-trip No cloud costs — inference is free The tradeoff is raw capability: on-device models are smaller and less powerful than frontier cloud models. But for many use cases like summarization, chatbots, or local search, they're more than good enough. About NobodyWho We'll use the NobodyWho library throughout this tutorial. It wraps llama.cpp in Rust and exposes a clean React Native API for running locally any model in .gguf format. Install it with npm install react-native-nobodywho or npx expo install react-native-nobodywho for Expo. Loading a Model NobodyWho can download a GGUF model for you directly from Hugging Face, cache it, and reuse it on every subsequent launch. That means you don't need to bundle anything into your app or manage downloads yourself: import { Chat } from " react-native-nobodywho " ; const chat = await Chat . fromPath ({ modelPath : " huggingface:NobodyWho/Qwen_Qwen3-0.6B-GGUF/Qwen_Qwen3-0.6B-Q4_K_M.gguf " , }); The first time this runs, the model is downloaded to the app’s cache directory. Every call after that loads the model directly. modelPath accepts a few different forms: Form Example Notes HuggingFace reference hf

I maintain no_human . It's open source, and this month I'm getting it ready for outside contributors, so this post is part announcement, part ask. What it does: no_human proves the code it wrote is correct. You drop a ticket on the board (or point it at Jira or Linear) and it plans, writes the code, and opens a pull request. Before that PR reaches you, the work is checked by a second model that never saw the coder's session and is told to assume the job is not done. You get a pass/fail checklist that cites files and lines, not a score. If the agent deleted or weakened a test, a tamper guard stops the attempt. For bug fixes, the tests offered as proof have to fail on the old code and pass on the new. It's free and open-source, on your machine. If you're thinking about contributing, here's what you'd be walking into. You don't need a Claude account to work on it. The test suite is hermetic: uv sync --frozen && uv run pytest -q -n 4 runs all ~2,980 tests without ever calling a model. A credential only comes into play if you want to run the product end to end. The good first issues are scoped down to file and line, each with a repro and the command that verifies the fix. Past those, the one I most want help with is backend adapters . The implementer runs behind a narrow protocol, and I want adapters for more coding agents: opencode, Aider, Goose, Crush, Amp, Qwen Code, and a longer list in the issue. One agent per PR, and comment before you build. Some of these tools have no headless mode, and I'd rather tell you that before you spend a weekend finding out. Not everything needs Python, either. There are open invitations for UX polish on the web board — frontend and design contributions, with the rule that a sketch or screenshot comes before code — and for making the PRs the agent opens read better : the PR body is the artifact a human judges, and right now it's information-dense but plain. Fair warning about scope: only the coder seat is swappable. The reviewer, planner

A maintainer once watched an AI assistant confidently recommend merging a pull request that deleted a test file. The prompt had included the entire issue thread, the last three commits, and a README from another branch. The model trusted every word because the prompt gave it no reason to filter. The result was a confident but false analysis. The root cause was not a bad model. It was context pollution: unrelated diffs, stale comments, and duplicate code snippets pushed the actual change below the model's attention threshold. For open source reviewers on a free tier, every wasted token also makes the loop slower. The fix is not a bigger context window. It is a smaller, better one. Why Full Context Collapses AI Reviews Long paste sessions fail for reasons that have little to do with model quality. The following failure modes appear regularly in OSS review flows when someone dumps everything into a chat: Issue threads contain outdated suggestions that contradict the current implementation. Full-file dumps include boilerplate that drowns the one-line semantic change. Old test output from another environment appears as evidence even when it no longer applies. Models weigh every token relatively evenly, so irrelevant lines consume attention that the diff deserves. Earlier articles on this account covered the reproduce-patch-test loop, but the missing discipline is context slicing. Slicing means choosing exactly which lines the AI sees, and nothing more. The Three Layers of Slicing The practice breaks into three layers, each with a clear source for truth: Patch layer — the diff and commit message only, not the full conversation history. Code layer — the definitions and tests touched by the diff, not every import in the project. Environment layer — exact commands and expected outputs, not historical logs from an old CI run. Together those layers describe "what changed, what it touches, and how to prove it works." That is enough for a reviewer model to produce a focused anal