标签：#AI

Andrew Swerdlow shares how Roblox scales autonomous software development from prompt to production. He discusses building robust security sandboxes, extracting institutional knowledge via code review exemplars, updating engineering infrastructure, and redefining productivity metrics around feature velocity and long-running AI turns to achieve trusted, automated deployment at scale. By Andrew Swerdlow

Even though the US has relaxed its restrictions of AI chip exports to China, illegal exports are apparently still taking place.

These WIRED-tested dual-purpose air purifiers also function as heaters, fans, art pieces, and more, offering the best of both worlds.

Two audio players do not make a fair before-and-after test. If the second player restarts from zero or takes half a second to load, the user is no longer comparing two versions of the same moment. They are comparing two memories. That is a weak way to evaluate any audio effect. It is especially weak for AI processing. A denoiser can remove a fan while softening consonants. A de-reverb model can reduce the room tail while making the voice sound less natural. The output may be cleaner without being better. The preview therefore has one job: let the listener switch quickly enough to hear both the improvement and the damage. The rule I use is deliberately boring. Both versions should contain the same edit and play from the same position. Switching should not restart playback or create a pause. The interface should not hint that one version is supposed to win. Two independent <audio> elements fail surprisingly quickly. Each owns its playback state, buffering behavior, clock, and seek operation. The user ends up finding the same position twice and comparing one sound with a memory of another. A better interface has one transport and one version control: [ Play ] [ Original | Processed ] 00:18 ━━━━━━━ 00:42 The transport decides where playback happens. The segmented control decides which signal is audible. One transport, two signals For a short preview, I decode both files into AudioBuffer s, start them at the same AudioContext time and offset, and route each through its own GainNode . Both sources run; only one gain is open. decodeAudioData() decodes complete file data and resamples it to the context's sample rate. The decoded buffers can then share the same audio clock. See the MDN documentation for format and loading details. The core is small: const context = new AudioContext (); const originalGain = context . createGain (); const processedGain = context . createGain (); originalGain . connect ( context . destination ); processedGain . connect ( context . destination )

So I spent the last two weeks running two open-source AI agents in parallel: OpenClaw and Hermes Agent (from Nous Research). I went in expecting to pick a winner. I came out realizing it's not really a "pick one" situation at all. These two projects represent two very different design philosophies — one is built around connection and control , the other around learning and growth . Which one fits you depends on whether you want an obedient tool or a companion that evolves with you. Here's my full breakdown after using both for deployment, daily tasks, and the general "living with it" experience. Two philosophies, two products OpenClaw takes a gateway-first approach. It's a persistent controller that handles routing, permissions, multi-channel integration, and skill orchestration, with pluggable models. The core promise: connect everything, execute predictably. Hermes Agent is built around a learning loop. The agent creates and refines its own skills as you use it, and keeps deepening its model of you over time. The core promise: the more you use it, the better it knows you. A rough analogy: OpenClaw is like a senior assistant who strictly follows the instruction manual — plus a universal adapter. Hermes is more like a teammate who writes their own manual after every task and keeps improving it. The four things that actually differentiate them 1. Skills: ready-made ecosystem vs. self-compounding OpenClaw: human-written skills distributed via ClawHub. Huge ecosystem, works out of the box. Hermes: the agent generates and iterates on skills by itself. Less rich in the short term, but it compounds over time. 2. Memory: good enough vs. actually remembers OpenClaw's default memory is fine (files and Markdown supported). But Hermes' four-layer memory architecture is noticeably more persistent — the difference becomes very tangible after a couple of weeks of use. 3. Autonomy: decisive vs. controllable Hermes is extremely strong when the task is clear — it often nails things

All praise to almighty God, and thanks to Google and the DEV Team, a while back, I won the Google...

In one test clip, the auto subtitles looked almost perfect. Then one auto subtitle showed gp where the speaker had actually said HP . It was one token in a long transcript, and that was exactly the problem: nothing in the editor made it look more dangerous than the clean words around it. Disclosure: AI helped me edit and structure this article. The gp / HP mistake came from my own build, and I checked the technical details against the code and the working editor. I ran into this while building a subtitle editor. The ASR system already returned word-level timing and confidence values, but a polished block of text made every word look equally trustworthy. The model exposed uncertainty; the interface hid it. That led me to a narrower engineering conclusion: Auto subtitles are drafts. An accuracy score describes a model result; it does not define a finished review workflow. Why auto subtitles need more than one accuracy percentage Speech-to-text systems are often evaluated with word error rate , or WER. In its simplest form: WER = (substitutions + deletions + insertions) / reference words That is useful for comparing transcripts against a known reference. For auto subtitles, trouble starts when a model-level metric is turned into a product-level promise. Suppose a 100-word transcript contains one wrong word. Its word accuracy may look excellent. But a single auto subtitle can carry very different consequences: Changing “and” to “an” may be harmless. Changing a person’s name damages trust. Changing 15 to 50 changes the meaning. Changing HP to gp made my test caption look careless. Dropping “not” reverses the sentence. WER counts errors. It does not price their consequences. Good auto subtitles also depend on things that a transcript-only score does not fully describe: whether words appear at the right time; whether cue boundaries follow the sentence; whether a line is readable before it disappears; whether punctuation helps or hurts comprehension; whether the user knows

Every card in RealFeedApp has a cover image. They aren't fetched from the articles — publishers' images come with rights I don't have — so the app uses its own bank, generated ahead of time, one pool per topic. I generated that bank once, shipped it, and this month threw all of it away and started over. Twice over, actually, because there were two separate failures and only the first one was my fault in the obvious way. Failure one: I got exactly what I asked for The original prompt asked for a dark, moody look — very dark near-black background , generous negative space . In a preview grid at full size, the results were genuinely nice. Restrained, editorial, not the usual glowing-blue-circuit-board thing. Then I looked at the actual feed. Cards render as tiles a bit under 400 pixels wide. A small object floating in a large field of black, scaled down to a tile, is a black rectangle. Not a bad image — no image at all. The model had done precisely what I asked: it put a modest subject in a lot of empty darkness. Negative space is a compositional virtue at poster size and a bug at thumbnail size. The lesson is dull and I'll probably need it again: prompt for the size the image will be seen at, not the size you review it at. I was approving art in a grid of large previews and shipping it into small tiles, and never once compared the two. The rule that replaced the old one is three words long — brighter, higher contrast, subject filling the frame edge to edge. Failure two: the model started writing the news The rewrite asked for documentary photography. The first batch came back with something I didn't expect: several images contained a coloured band along the bottom of the frame with a headline in it. Invented words, mangled letterforms, confident typography. One read TROOLDOGS NEWS . Three images out of fifteen. Not a fluke, a pattern. The cause was in the prompt, and it was three words working together. I had asked for an editorial look, described the images as news f

The 9.58-second 100-meter dash record set by Usain Bolt in 2009 has been outpaced by Chinese robots participating at the World Humanoid Robot Games in Beijing. In a preliminary heat on Saturday, Tiangong Ultra, made by the Beijing Humanoid Robot Innovation ​Center, ran the distance in 9.39 seconds, followed by the Honor-developed Lightning at 9.47 […]

Ask a team how their RAG pipeline works and they will tell you about the embedding model, the vector database, and maybe the reranker. Ask them how they chunk their documents and you will usually get "uh, 500 tokens with some overlap? Whatever the default was." That default is quietly deciding the quality of every answer the system gives. Chunking is the highest-leverage, least-discussed decision in a RAG pipeline , and I want to convince you of that with concrete examples rather than hand-waving. The refund policy that got sliced mid-sentence Say your docs contain this refund policy: ## Refund policy Customers may return items within 30 days of delivery for a full refund. Items must be unopened and in original packaging. Opened electronics are subject to a 15% restocking fee. Sale items are final and cannot be returned unless defective. Defective items can be returned within 90 days regardless of sale status. Now run it through a fixed-size chunker, the kind that cuts every N characters. Depending on where the boundary lands, you can get a chunk like this: original packaging. Opened electronics are subject to a 15% restocking fee. Sale items are final and cannot be returned unless A user asks "can I return a sale item?" The retriever finds this chunk (it literally contains "Sale items are final and cannot be returned unless") and hands it to the model. The model reads it and answers "sale items are final and cannot be returned." The critical exception, "unless defective," was decapitated by a character boundary. The 90-day defective window lives in a different chunk that scored lower and never made it into the prompt. Nothing in your stack is broken. The embedding model is fine, the vector database is fine, the LLM did exactly what the context told it to. The answer is still wrong, and it is wrong because of an off-by-one in a splitting function nobody has looked at since the prototype. A heading-aware chunker would have kept the whole "Refund policy" section toget

The shifts that actually matter for builders - late May to mid-August 2026 The last three months did not produce a single "GPT-5 moment." There was no single release that reset the conversation the way earlier step-changes once did. Instead, the ground moved in several places at once: a wave of frontier and open-weight model launches in July, growing candor about how badly long-context windows actually hold up, and a genuinely uncomfortable security story out of xAI's new agent product. Here's the short, opinionated version of what actually changed for people who ship AI systems. 1. Models & Capability GPT-5.6 (OpenAI) shipped in three tiers - Sol, Terra, and Luna after a government review, with the fastest tier reportedly hitting 750 tokens/sec on Cerebras hardware and a new "Ultra" mode for maximum reasoning effort. Anthropic's lineup grew fast: Opus 5 landed at unchanged Opus pricing ($5/$25 per million tokens), reportedly within half a point of a rival's benchmark peak at half the per-task cost, alongside a new Sonnet 5 and a higher "Fable 5" tier. xAI iterated twice: July's Grok 4.5 (1.5T parameters, trained partly on coding-agent interaction data) was followed by Grok 4.6 on August 12 - a 500K-token-context model aimed at coding and long-running agents, priced at $2/$6 per million tokens standard and $4/$12 for long-context requests. Google's Gemini Flash line saw three releases in quick succession - 3.5, 3.6, and then 3.7 Flash - each undercutting the last on price. 3.6 Flash alone cut output pricing from $9.00 to $7.50 per million tokens. Open-weight competition intensified: Kimi K3 (Moonshot) became the largest open release yet at 2.8T parameters (104B active via MoE) with a 1M-token window, and it was joined by DeepSeek V4-Pro, the Qwen3.8 series, and GLM-5.3 - plus Inkling (Thinking Machines), a 975B open-weight MoE trained on 45 trillion multimodal tokens. One-line interpretation: The capability ceiling is still rising, but the more interesting number th

AI-Powered Privacy Policy Generators LLM‑driven privacy policy generators have moved from experimental prototypes to production‑grade services in 2026, offering on‑demand, jurisdiction‑aware drafts that can be directly embedded into compliance pipelines. Tools such as PrivacyGPT and PolicyCraft combine retrieval‑augmented generation with rule‑extraction models, turning natural‑language privacy intents into enforceable policy clauses that can be exported as JSON‑LD or plain‑text templates. Deep Dive Architecture PrivacyGPT leverages a hybrid architecture: a domain‑specific transformer fine‑tuned on 10 million privacy statements, paired with a deterministic rule engine that maps extracted obligations to GDPR, CCPA, and emerging AI‑Act provisions. PolicyCraft adds a feedback loop where the generated draft is automatically validated against an internal compliance knowledge graph; mismatches trigger a self‑correcting prompt that iteratively refines the text until a confidence score above 92 % is achieved. Real-World Engineering Examples A fintech startup integrated PrivacyGPT via its CI/CD pipeline; each pull request that modifies data‑collection code triggers an API call that updates the “Data Retention” clause, keeping the public policy in sync with code changes. A multinational e‑commerce platform deployed PolicyCraft to generate locale‑specific consent banners; the system produced 27 variants in under five minutes, each certified against the EU’s Digital Services Act. Zero‑Trust Architecture for Rule Enforcement Zero‑trust architecture (ZTA) starts from the assumption that no network segment—whether on‑prem, cloud, or edge—can be implicitly trusted. Instead of a perimeter, every request is evaluated against a continuously refreshed identity profile that fuses user credentials, device posture, and behavioral risk scores. In practice, this means deploying a Policy Decision Point (PDP) that consumes attributes from an identity provider, a device‑trust service, and a tel

*Part 2 of "Multi-Agent Systems in Production: What They Don't Tell You", a four-part series...

Building a Scalable, HIPAA‑Compliant Healthcare Document Processing Pipeline in .NET & Azure Quick Answer A deep dive into architecting a production‑grade Healthcare Document Processing Pipeline—covering AI extraction, FHIR integration, vector search, and compliance at scale. In my experience, the biggest cost is not the AI model, but the orchestration that turns raw scans into audit‑ready FHIR resources. The right mix of services can reduce latency by 30‑50% while keeping the bill below 10% of the raw compute budget. Choose services that expose a BAA and native hybrid search (Azure Cognitive Search) to avoid a second compliance layer. Prioritize deterministic scaling (Container Apps + Aspire) over elastic serverless when real‑time SLAs are tight. Version your embeddings; treat the vector index as a first‑class contract. HIPAA‑Ready High‑Volume Document Ingestion When a health system starts ingesting thousands of paper‑to‑digital documents per day, the naïve “scan‑and‑store” approach quickly becomes a compliance and performance nightmare. The real challenge is to produce HIPAA‑ready, FHIR‑compliant, low‑latency data that can be consumed by downstream clinical decision support or billing systems. Compliance is not a checkbox; it’s a series of audit trails that must survive a 30‑day retention policy and survive a forensic review. In production, the cost of a single PHI exposure can exceed the annual budget of the entire platform. Real‑World Example Consider a mid‑size hospital that receives 25,000 inpatient discharge summaries, 8,000 lab reports, and 12,000 imaging PDFs every month. Each document is a mixture of scanned images, PDFs, and legacy forms. The billing team needs structured diagnoses and procedure codes within 30 seconds to avoid claim denials, while the analytics team wants similarity search for rare disease cases in the last 12 months. The pipeline must: Extract structured entities with ≥95% accuracy. Redact PHI in transit and at rest. Provide audit logs

There's a very specific kind of AI project that looks incredibly impressive in the architecture diagram and does almost nothing a simple version couldn't do better. It has a vector database. It has a multi-agent orchestration graph. It has a fine-tuned model, a memory layer, custom tool wrappers, three retries with exponential backoff, and a couple of "future-proof" abstractions nobody's actually using yet. The agent at the center is simple. The scaffolding around it is a cathedral. Here's the uncomfortable truth most teams learn the hard way: AI apps rarely fail because someone picked the wrong model or framework. They fail because layers got added before anyone could name the problem each layer was supposed to solve. The biggest mistake in building AI apps isn't starting too small — it's starting too big. So here are 7 signs you've crossed into over-engineering, the simpler thing to do instead, and — at the end — a practical playbook for not falling into the trap in the first place. See how many feel a little too familiar. 1. You reached for a vector database before you needed one "First, set up your vector database" became the default opening line of every AI tutorial — so teams spin up Pinecone or Chroma reflexively, before they've confirmed they even have a retrieval problem that requires embeddings. The plot twist of the last year is how often that's overkill. Some of the most capable coding agents around quietly dropped vector search in favor of plain tool-driven search — grep, reading the file tree, asking for files by name. In one widely-cited case, ripping out the embedding pipeline and replacing it with grep reportedly outperformed the vector setup, by a lot. That doesn't mean vector DBs are dead — they're still a strong fit for large, stable knowledge bases (product docs, FAQs, glossaries) with a good reranker. But if your data is small enough to fit in context, or searchable with keywords and filters, you may be maintaining an entire embedding-and-migra

This is a simplified guide to an AI model called Beat_this maintained by Xavriley . If you like these kinds of analysis, you should join AImodels.fyi or follow us on Twitter . Overview beat_this is a beat and downbeat tracking model from the ISMIR 2024 paper "Beat This! Accurate Beat Tracking Without DBN Postprocessing" by xavriley and collaborators at CPJKU. The model detects precise beat positions and downbeat boundaries in audio files without relying on Dynamic Bayesian Network postprocessing, achieving state-of-the-art F1 scores while maintaining generality across diverse music genres. The architecture alternates convolutions with transformers operating either over frequency or time dimensions, and is trained on multiple datasets including solo instruments, pieces with time signature changes, and classical music with high tempo variations. The main model ( final0 , final1 , final2 ) weighs approximately 78 MB each, with a smaller variant available at 8.1 MB. The most critical detail before using it: the model achieves good results specifically because it avoids meter and tempo constraints that traditional systems impose, but this means it can still fail on difficult and underrepresented genres and performs worse on continuity metrics compared to methods using postprocessing. Best use cases Music information retrieval and analysis workflows. If you build music analysis software that needs to segment tracks into beat-aligned sections for tempo detection, structural analysis, or synchronization with other modalities, beat_this provides clean beat and downbeat annotations without requiring external postprocessing pipelines. The model outputs precise timestamps suitable for downstream music information retrieval tasks like onset detection or harmonic analysis. Rhythm-aware music production tools. For digital audio workstations, beat detection plugins, or metronome applications, this model provides frame-level accuracy suitable for real-time audio alignment and grid s

A coding agent with access to your entire repository does not necessarily understand your system better. It may understand less. Because a large repository may contains obsolete code, and decisions that were never written down. Giving an agent more files increases the amount of text it can inspect, but this does not guarantee it will identify the constraints that matter more. The better design is a context packet a small, versioned, machine-readable description of the system. The packet complements source code by recording the contracts and decisions that source code alone may not reveal. The Problem: Repository Access Is Not System Understanding A normal coding request might look simple: Add retry handling to the payment notification worker. An agent can find the worker, inspect its dependencies, and produce a patch quickly. But a safe implementation depends on questions that may not be answered in the worker's directory: Is the message delivered at least once? Does the payment provider support idempotency keys? Which exceptions are transient? Does the consumer rely on a specific delivery count? Can this change be deployed independently of the producer? The repository may contain clues, but clues are not contracts. When the agent receives only the ticket and nearby files, it fills the gaps with plausible assumptions. When it receives the entire repository, it has a different problem: the important rule may be surrounded by thousands of irrelevant or contradictory signals. The gap comes from context design. Retrieval Boundaries and Signal Density AI coding systems have a finite context budget. The deeper concern is signal density : the proportion of useful constraints among all the material an agent must interpret. Suppose an agent receives 100 files: 10 define the target feature 20 are related infrastructure 30 are historical implementations The agent can technically read all of them. It still has to decide which rules apply, which code is authoritative, and which

We run ~100 LLM agents unattended on local models. Last week we found one document that had been rewritten 245 times in 5 days — every attempt rejected. A sibling document: 225 times. Combined, about 470 wasted generations, all burned on the same two files. Here is the autopsy, with the actual numbers. The loop Our pipeline is simple: a producer agent writes a document, a reviewer agent checks it against a contract (minimum length, required sections, no placeholder junk), and rejected work goes back with fix instructions. The rejected document was a key-management (KMS) implementation spec — 4,452 characters, perfectly on-topic. The reviewer's verdict: "The request was a 3-line email triage response (LOCK / VERDICT / REASON), but the answer is a long KMS spec. Rewrite as 3 lines only ." One problem. We grepped the document: the words "LOCK", "VERDICT", and the name of the triage service appear zero times in it. The reviewer had invented the request. Why the loop never ended Two contracts collided: The reviewer's fix instruction: output 3 lines only The producer's output contract: minimum 600 characters No output can satisfy both. So the producer failed the contract, got re-queued, produced again, failed again — 245 times. Our retry cap counted reviews , but a contract-failed output never reaches review. The give-up mechanism existed; it just watched the wrong counter. Root cause: the reviewer never saw the request Our review prompt contained the artifact body (first 4,000 chars) and the output format. It never contained the original request. We asked a model "does this match the request?" without telling it what the request was. A model asked to judge against information it doesn't have will hallucinate that information. Ours did, confidently, 245 times' worth. Bonus failure: we truncated long documents to 4,000 characters before review without saying so, and reviewers marked them "thin — cut off mid-sentence." The cut was ours, not the producer's. How common was it

When you run multiple agents across Claude, ChatGPT, and Cursor, each one starts from scratch unless you manually paste context into every session. OzBrain solves this by exposing a shared knowledge substrate that agents read and write through the Model Context Protocol (MCP). The system routes context so agents see only what they need, and teams avoid explaining the same facts to every new agent instance. The Show HN post drew 85 points and 50 comments because the problem is real: production multi-agent workflows break down when context lives in isolated chat histories or scattered documents. OzBrain's architecture treats knowledge as a first-class resource with explicit scoping, indexing, and conflict resolution. Storage Layer and Scope Boundaries OzBrain organizes knowledge into brains , which are either personal or shared. Each brain holds structured knowledge units that agents query through the MCP connector. The system decides scope at write time: Personal brains store user-specific preferences, writing style, and private project state. Shared brains hold team-wide facts like client contacts, project decisions, and open threads. When an agent writes to OzBrain, it specifies the target brain. The MCP connector enforces access control: agents can read from any brain the user has joined, but write permissions depend on the brain's sharing policy. This prevents accidental leakage of personal context into team memory. The storage layer tags each knowledge unit with metadata: creation timestamp, last update, and a freshness indicator (fresh, aging, stale). Agents use these tags to decide whether to trust the stored fact or re-query the source. Indexing Strategy and Query Routing OzBrain does not load the entire knowledge graph into every prompt. Instead, it maintains a routing index that maps topics to knowledge units. When an agent queries for "client contacts," the index returns pointers to relevant units without pulling in unrelated project state. The routing ind

Originally published on tamiz.pro . The field of AI agents has moved rapidly from single-model executors to complex multi-agent orchestration. But after running 157 agent deployments across diverse task domains, one pattern emerged with striking consistency: planning quality predicts success far better than execution speed or model size. This isn't just theoretical—it's a practical lesson that's reshaping how engineers architect agent fleets, giving rise to what we're now calling Orca-style agents : hierarchical, planning-first systems that separate the expensive business of thinking from the cheaper business of doing. The Experiment: 157 Agent Runs Over six months, our team deployed and monitored 157 distinct agent runs across four primary use cases: code generation pipelines, automated testing workflows, infrastructure-as-code provisioning, and data transformation tasks. Each run varied along three dimensions: Architecture : Single-agent vs. flat multi-agent vs. hierarchical (Orca-style) Planning depth : No planning, brief intent statement, or full recursive planning loop Execution model : Direct LLM call per action vs. tool-augmented execution with validation The results were unambiguous. Systems that invested 3-5x more tokens in planning achieved 4.2x higher task completion rates and 3.8x fewer rollback cycles compared to agents optimized purely for fast execution. The correlation between planning sophistication and success held across every domain. Why Planning Beats Raw Execution The intuition behind this finding rests on an economic principle of LLM usage: planning is cheap relative to costly mistakes . A well-structured plan reduces the probability of executing the wrong sequence of tools, making incorrect API calls, or generating code that fails integration testing. Consider the token economics: Phase Tokens (typical) Cost impact Planning (intent + decomposition) 800–2,500 Low Execution per subtask 300–1,200 Medium Correction after failure 1,500–4,000 High