标签：#AI

Last week OpenAI published its technical report on the Hugging Face incident, METR published an independent one, and the headlines turned it into "AI broke loose". It did happen. That part is real. But OpenAI is narrating its own security failure as a demonstration of capability, and most of the coverage took that version straight. I read the OpenAI post, the METR report and a few of the critical takes. Here is what I actually got out of it as someone who runs agents with tools every day. What happened, short version Between May and July 2026, agents in OpenAI's internal RL training and evaluation runs found a way to talk to each other through Artifactory, the package manager hosted inside their sandbox. They turned it into a message board. Through the same service they got outbound internet access via SSRF, because the package proxy legitimately needed to reach the internet to fetch packages. On July 4 the message board traffic took Artifactory down. Security rebuilt it, which wiped the board. Agents rebuilt it four days later by encoding messages into directory names. Then it escalated. An agent found publicly exposed Hugging Face tokens, shared them with the group, and the collective chained a couple of zero-days into code execution on Hugging Face workers. Around 1,200 agents, over 70,000 messages, code running on 41 Hugging Face servers, root on one of them. Hugging Face disclosed it on July 16. OpenAI admitted its models were behind it on July 21. Real incident, real zero-days, real third party affected. Nobody disputes that. Three things the headlines skip It was not a conspiracy of 1,200 minds. Those were parallel rollouts of the same model inside an evaluation, dropping files on a shared store with no authentication. The "secret message board" was directories in a package manager. Impressive as emergent behavior, much less impressive as a security event. It was not a plan, it was reward hacking. Out of 898 tasks in the ExploitGym benchmark, 198 had never be

I think we are still talking about AI memory in the wrong way. Most implementations are variations of...

X found a bot farm in its investigation of inauthentic Chinese accounts. Out of 200,000 bots, 200 allegedly focused on posting against AI data centers.

You’ve probably used Gemini to analyze hours of video, summarize podcasts, or answer questions from...

ToolJet was the first internal tool builder to go AI-native, but ToolJet MCP takes that idea...

'The empty invocation of national security is not a blank check to punish and retaliate against government critics.'

The review passed. The deployment failed. An engineer moved a code-review agent to a free server. The model answered correctly in every test. Then the server hit its quota at 2:47 PM on day three. Fourteen pull request verdicts vanished with the session. No state. No logs. No retry. This is the reviewer's blind spot. Teams test models obsessively. They rarely test the runtime underneath. This guide covers one decision: refusing a free server for an agent. It lists red flags, better alternatives, and exit criteria. It also names a concrete example: MonkeyCode's free model access and free server option. Disclosure: This article was prepared as part of MonkeyCode's product outreach. What "free" actually includes MonkeyCode is an open-source agent platform. It offers free model access and a free server option. The free model access includes 10 million tokens per cycle, per the project's published claim. The free server runs the agent without a paid VM. Those offers are real. They are also constraints. Free infrastructure is a budget, not a promise. Treat it like a trial environment, not a production contract. Free tiers exist to convert users, not to run production. That is fine. The mistake is treating them as infrastructure. Three failure modes Free infrastructure fails in predictable ways. Know all three before committing. Mode one: quota exhaustion. Token budgets reset on a schedule. Heavy days burn the whole cycle. The failure is silent. The agent stops mid-task. Mode two: state loss. Free servers restart without warning. In-memory sessions disappear. Long-running agents lose context. Recovery is manual. Mode three: contention. Shared resources mean cold starts. Neighbors consume CPU. Rate limits appear at peak hours. Latency becomes a random variable. Red flags: check before committing Run this checklist before any migration. One red flag means pause. Two mean stop. Hard deadlines. The agent gates CI or on-call responses. A quota reset cannot wait. Daily burn exce

Classic Machine Learning Through the Eyes of an SRE — Part 9: Isolation Forest The algorithm in one line: Isolation Forest scores how anomalous a point is by how few random cuts it takes to separate that point from everything else. No model of normal, no loss function, nothing optimized. ← Previous: Part 8 — Hierarchical Clustering Fails Beautifully · Next: this is the series finale — start at Part 1 . Every anomaly detector I had studied models what NORMAL looks like, then calls the leftovers outliers. K-Means: far from every centroid. DBSCAN: in the noise bucket. Sensible, and intuitive. Isolation Forest does not bother. It never models normal at all. It goes straight at the rare points with a single question: how few random cuts does it take to isolate you? Random cuts, literally. Pick a feature at random, pick a split value at random between that feature's min and max, repeat. A point that separates from the crowd in three cuts is anomalous. A point buried in the middle of a dense mass takes thirty. Grow hundreds of these random trees, average the isolation depth for each point, and you get an anomaly score. There is no loss function here. No optimization, not even the local kind that decision trees do at every split. Every cut is a coin flip, and the power comes entirely from averaging, which is the forest trick from the supervised half of this series now applied to pure randomness. Cheap randomness plus averaging beats careful modeling, as long as the target is something randomness naturally exposes. Rarity is exactly that. Sometimes the winning move is to optimize less. That sentence would have gotten me laughed out of my first ML study session. It is also this finale's thesis. The part I had completely backwards Here is the thing I did not know until I read the original paper properly, and it is the opposite of every instinct a decade of ops gave me. Isolation Forest deliberately trains each tree on a small subsample of your data, and this is not a performan

Free Tokens Are Not an SLO: An Ops Cost Drill for AI Batch Queues This week, two numbers trended: a harness at 100%, a model at 30%. For platform teams, a better pair is queue age and deadline slack. This article is a cost drill for the simplest AI batch path: free tokens, free server, non-negotiable deadline. Disclosure: This article was prepared as part of MonkeyCode's product outreach. MonkeyCode offers free model access and a free server option. That capacity is real. It is not an SLO. The tokens cost nothing. The queue is patient. Your deadline is not. The missing variable Token cost is easy to measure. Operations cost is easy to ignore. A free endpoint converts a per-token bill into a per-hour bill. The bill becomes your time, your retries, and your queue age. This drill keeps the ledger honest. It answers one question: what does a completed request cost when the token price is zero? Topology # worker.py (minimal, single-threaded) import queue import time import csv work = queue . Queue () for i in range ( 1000 ): work . put ({ " id " : i , " prompt_tokens " : 512 , " max_tokens " : 256 }) def call_model ( payload ): # replace with your free model endpoint return { " ok " : True , " in_tokens " : 512 , " out_tokens " : 180 } completed = 0 retries = 0 started_at = time . time () while not work . empty (): item = work . get () attempt = 0 while attempt < 4 : try : call_model ( item ) completed += 1 break except Exception : retries += 1 attempt += 1 time . sleep ( 2 ** attempt ) The worker is deliberately single-threaded. Free capacity often serializes. Serialization turns a token problem into a time problem. Declared test conditions 1,000 requests. One worker process. One free model endpoint. No client-side rate limiting. Deadline: 30 minutes. Ledger: one CSV row per request. Ledger and report # cost_ledger.py import csv import time HOURLY_OPS_COST = 50.0 # loaded engineering rate, adjust def record ( item , elapsed , retries ): with open ( " ledger.csv " , " a

On Thursday, a judge ruled that the Pentagon's blacklisting of Anthropic earlier this year was unconstitutional, delivering the AI lab a win in a monthslong rollercoaster of a battle with the Trump administration. The lawsuit, filed in March in a California district court, accused the Trump administration of unlawfully retaliating against Anthropic for setting "red […]

Your Free AI Server Will Fail Quietly. Five Gates to Make It Loud. The model can be innocent. The server cannot. Earlier this week I wrote a fail-closed checklist for AI-generated code. That list guards against the model writing something dangerous. This list guards against something duller: the server around it dying at 2 a.m. while the model stays online the whole time. Nobody sees that failure until a user does. The setup I am testing MonkeyCode for a small side build: a log-summarizing API. The project gives you free model access and a free server option, which is exactly the toy setup I like. Ten lines of app logic. Zero dollars. One honest problem: free infrastructure is someone else's best effort. Disclosure: This article was prepared as part of MonkeyCode's product outreach. Before you judge, my plan was simple. I deliberately killed my own server to see where the stack would fail. Then I wrote gates that make each failure loud. The kill test Here is the failure sequence, reproduced on purpose. The server process died. No restart policy. Connections hit a dead socket. Nothing answered. The client had no timeout and waited forever. No health probe. No alert. No log line. Four hours later, the model was still happy. The server was still dead. The tool was still broken. The model was innocent the whole time. The harness was the guilty one. The problem was never intelligence. It was silence. So here are five gates, ordered from cheapest to most annoying. Gate 1: A kill switch that outlives the process A crash bug can take down your app. It can also take down your ability to disable the app. So the switch lives outside the app. KILL_FILE = " /tmp/disable-monkeycode " @app.post ( " /summarize " ) def summarize ( logs : str ): if os . path . exists ( KILL_FILE ): raise HTTPException ( 503 , " disabled by operator " ) ... Why a file and not a database row? Because the DB may be down when you need the switch most. A file survives restarts. You can touch it from cron.

An AI agent can take an action. An AI employee needs to know what happens next. Most AI agents look something like this: Think → Act → Observe → Repeat That's fine for short-lived tasks. But an AI employee needs to work across hours, days, and weeks. It needs to remember: What happened Who owns the work What is waiting What changed What should happen next When it should wake up When a human needs to approve something That's where graph engineering becomes interesting. This is the architecture behind Roster : software that can own work the way an employee does, not just fire off a single tool call. Events wake someone up. A graph holds state, ownership, and history. The agent reasons, acts, writes the result back, then sleeps until the next event. For Roster, the loop looks like this: Event ↓ Graph ↓ Agent ↓ Action ↓ Graph Update ↓ Sleep ↓ Wake Again Let's build a tiny version. Table of Contents 1. Model the Work 2. Build the Graph 3. Add Events 4. Build the Agent Loop 5. Add Scheduling 6. Build a Tiny AI Employee 7. Put It Together 8. The Bigger Idea 1. Model the Work Imagine an AI employee called Maya. Her job is simple: Follow up with sales leads. Her world contains: Maya ↓ owns Lead ↓ belongs_to Company ↓ contacted Email ↓ replied_to Customer We don't need a massive graph database. We just need nodes and relationships. 2. Build the Graph Here's a minimal TypeScript graph: type Node = { id : string ; type : string ; data : Record < string , unknown > ; }; type Edge = { from : string ; to : string ; type : string ; }; class Graph { nodes = new Map < string , Node > (); edges : Edge [] = []; addNode ( node : Node ) { this . nodes . set ( node . id , node ); } connect ( from : string , type : string , to : string ) { this . edges . push ({ from , type , to }); } neighbors ( id : string ) { return this . edges . filter (( edge ) => edge . from === id ) . map (( edge ) => ({ relationship : edge . type , node : this . nodes . get ( edge . to ), })); } } Now create Maya

In my first post, I wrote about why I spent my first week writing zero business logic and instead built rig - our lightweight, POSIX-compliant local provisioning tool. It was my way of rejecting "wiki-ops" and applying Infrastructure-as-Code (IaC) discipline to our local environments so that a hardware failure means minutes of downtime, not a week. But as I transitioned into Week Two, I was hit by a different kind of operational reality check. For years, I had been building a comprehensive repository of system architecture, design decisions, and guidelines on Confluence. It was my digital home. So, knowing I would be creating a startup, I set to work writing my documentation in my spare time in preparation. But during a brief hiatus of inactivity, the space was silently, unceremoniously deleted. It was gone. Late nights of ideas, patterns, templates, and reference materials vanished into the cloud ether. That loss was a violent reminder of a lesson I thought I'd fully mastered: if your documentation doesn't live alongside your code, you don't truly own it. Relying on third-party SaaS wikis to store the soul of your system architecture is just another form of "click-ops". It creates an artificial separation between the craftsmen writing the logic and the documentation that defines it. But rather than mourning my lost Confluence space, I treated it as a catalyst. I decided that our young startup would not have a bloated, detached corporate wiki. Instead, we would treat Documentation as a Contract - a unified, git-backed human-and-machine contract that serves as the precise, zero-maintenance boundary for our AI systems. Here is how losing my documentation led to a new architectural philosophy, and how we built a zero-overhead, "Anti-AI AI Strategy" that uses GitLab CI/CD and Google Workspace to run a secure, managed RAG pipeline. The Anti-AI Strategy: Why We Refuse to Let AI Write Our Code Walk into almost any tech startup today, and you’ll find developers blindly feed

Tuesday, 10:47 AM. Fourteen developers open their IDE extensions at once, and the shared AI server starts returning timeouts. Nobody planned for the morning spike. The free tier was announced on Monday, the team adopted it by Tuesday, and the first capacity incident happened before lunch. This article is a 30-minute load-test workflow for teams that just received access to a free hosted AI server. The goal is not to benchmark model quality. The goal is to find the concurrency ceiling before your team does — the hard way. The Free Server Is a Shared Resource Now MonkeyCode is an open-source AI coding project that offers free models and a free server. The offer is attractive for the same reason it is dangerous: it removes the two usual adoption barriers — API billing and self-hosting operations — and turns the server into a shared team resource overnight. Disclosure: This article was prepared as part of MonkeyCode's product outreach. A shared resource without a measured ceiling behaves like a shared database without connection pooling. It works in the demo, degrades under load, and fails at the worst possible moment: the morning standup, the release freeze, the day before the demo. The failure mode is not what most teams expect. It is not the token quota. It is latency collapse. Requests queue, timeouts cascade, and the IDE extension retries, which adds more load. The server does not die; it just becomes unusable. The Math: Little's Law for AI Requests Before writing any test code, define the model. Little's Law states that the average number of requests in a system equals the arrival rate multiplied by the average service time: L = λ × W L — average requests in the system (concurrency) λ — arrival rate, requests per second W — average service time per request, in seconds For an AI server, W is dominated by model inference time. A single code-generation request can take 10 to 40 seconds on a shared free server, depending on the model and the prompt length. That change

A boutique StrictlyVC evening returns to New York's West Village on September 10 with Keith Rabois, Craig Shapiro, Jason Levien, Tristan Walker, Brynn Putnam, and Deven Parekh — covering AI, sports investing, community-building, venture economics, and politics, with cocktails, food, and networking throughout the night.

Rockstar has officially published its "extended look" at Grand Theft Auto VI on YouTube and on its website, as promised. The in-depth preview, which "entirely" features footage captured from the PS5 version of the game, initially premiered on Netflix at 3PM ET. But because Rockstar allowed creators to post reaction videos, you've technically been able […]

MCP is changing how AI applications interact with the systems around them. An AI agent can now do...

God’s Eye View was the top project on GitHub Trending when we selected it for Jian AI Lab’s daily experiment. The pitch is immediately compelling. It brings aircraft, vessels, satellites, earthquakes, wildfire data, traffic, CCTV sources, and other feeds into one 3D globe. The repository also makes a serious effort to label data as live, modeled, reconstructed, or simulated. We tested commit b22573a9db28e47c324821ebdd4c67bdb241c0e1 on Linux with Node.js 24.19.0 and npm 11.9.0. Installation and security checks We first ran npm ci --ignore-scripts , reviewed the install-script sources, and then ran the normal npm ci . Both installations succeeded with 201 packages. The root project has no preinstall, install, or postinstall hook. Transitive install scripts come from esbuild, fsevents, Puppeteer, and sharp. npm audit --omit=dev reported no known vulnerabilities in production dependencies. A common secret-pattern scan did not find hard-coded live credentials. This is a limited check, not a full source audit. The project talks to many external services, including Google Maps, OpenAI, OpenSky, AISStream, NASA FIRMS, TomTom, CelesTrak, OSM, Open-Meteo, GDELT, and Radio Browser. It is local-first, but it is not offline. Server-side keys such as OpenAI and AISStream are read by the local Vite proxy. Google Maps and Cesium tokens are intentionally delivered to the browser. Users must restrict referrers and APIs and set provider budgets and quotas. 2,588 visible assertions passed The main test suite reported 2,587 passing assertions and zero failures. A separate focus-allocation check added one more passing assertion. The visible total was 2,588 passes and zero failures. The process did not exit after the summary. We waited more than 90 seconds and interrupted it manually. The final exit code was 130. The precise result is that all visible assertions passed, while the official test command did not complete with a clean exit in this environment. This may indicate an open handle

📝 Originally published (in Japanese) at forge.workstyle.tech . The Challenge of "Silence" in Unmanned AI Avatar Live Streams When creating a live stream where an AI avatar operates autonomously, the first major hurdle you encounter is the issue of "silence." It’s not that there are no viewers—quite the opposite. Yet the avatar falls silent for long stretches, or ignores comments for tens of seconds. What human streamers do unconsciously—creating "space" in the conversation—is entirely missing from AI behavior. In this article, I’ll summarize two key challenges we tackled to prevent unmanned streams from becoming boring. The first: how to fill the silence when no comments arrive. The second: how to handle response delays when comments do arrive. The former deals with behavior during "no input," while the latter concerns the time between input and reaction. Both are two sides of the same coin in live streaming, and neither worked with a straightforward implementation. What they had in common was that brute-force attempts to "make it faster" or "make it smarter" missed the mark. We had to observe long-running streams, measure breakdowns, and redesign priorities—mundane but essential work. Reactive Alone Doesn’t Make a Stream Our initial implementation was straightforward: "Respond when a comment arrives." Functionally, it worked correctly and passed tests. The problem was what happens when no comments arrive. In an unmanned stream, the avatar stands frozen on screen for tens of seconds—blinking, but doing nothing. This is nearly an accident for a live stream. And for newly launched channels, this is the default state. Comments come only after the stream has grown; until then, silence is the norm. This was a design philosophy issue. If built as a chatbot, the AI only outputs in response to input —just like a web request/response model. But a streamer is different. Their job is to keep talking even when no one says anything. So we needed a mechanism that generates speech

Last post, I said "the book is under review." Now the paperback is live. The Kindle edition is...