As the US sees its highest number of measles cases in decades and vaccination rates fall, researchers are developing drugs to help those who contract the virus or who are particularly vulnerable.

After you deploy half a dozen AI agents across a team, something weird happens. Friday afternoon, release day. The PM says their AI summarized the change impact. The dev says their AI reviewed the code and found nothing. QA says their AI ran the test suite and everything passed. Then production breaks. You dig through the logs and all you see is "system call." No way to tell which agent made which call, when, on what context, acting on whose behalf. Three agents sharing one service account, one API key, zero accountability. The humans end up taking the fall, and you can't even figure out which human to talk to. This isn't a thought experiment. It's what happens when you bolt AI assistants onto existing infrastructure without thinking about identity. Buy a batch of API credits, create a service account, share it across the team, done. That works fine when one person uses one assistant for their own work. It falls apart the moment multiple agents run in parallel across different roles. Permissions break first. A competitive research agent needs access to all project channel discussions. A code review agent should only see PRs and repository messages. That distinction doesn't exist in the service account model, which has a single binary switch: can access or cannot access. Teams work around it by manually creating groups, forwarding messages, and setting permission boundaries by hand. Add more agents and this manual isolation starts to crack. Some teams we've talked to ended up with over a dozen separate groups just to control agent visibility, with humans acting as message routers between them. At that point the AI is making things slower. The work history problem is more concrete. An engineer who's been on the team for three months, you know what they're good at, what they're sloppy at, which module they crushed last sprint. Next time you assign work, you use that information. An agent that's run a hundred tasks? Completion rate, rejection count, which task types it

Self-hosted radio with an AI DJ and one shared stream Discussion | Link

Summary More and more, I find myself overtaken by AI in my own field of expertise. Given only the materials, AI clears the specialized knowledge I spent years building up more easily than I had expected. This column takes a small thing that actually happened during collaborative development as its starting point, and thinks about what a specialist who has ended up on the overtaken side can make into a strength from here on. Where will the human role move next? How long will what I can hand over now stay something only I can produce? This is not a piece that settles the answer, but I use what happened in daily development as a clue to think through the question. Who this is for and what you can take away This column is for people who, in collaborative development with AI, have begun to wonder where to place their own expertise. Rather than lamenting being overtaken as such, I want to think through with you, from things that actually happened, what you can hold on to once you are on the overtaken side. I wrote it so that you can carry away the unease of handing work over to AI as a question for rethinking your own role. I hope it becomes material for someone standing in the same situation to think about what they themselves would do. This article is a column based on things that actually happened one day during collaborative development, and on the record of the exchange I had with AI that day. In my own field of expertise, the moments of being overtaken by AI have clearly grown more frequent. There was one recently. It was when I added a feature for subscribers to comment to each other on this site. What I decided went only as far as the line that both reading and writing stay closed to subscribers alone; the implementation I left to AI. When the implementation was done, other AIs reviewed it from four viewpoints, tried to rebut each finding, and sent only the ones that survived on to be fixed. Two of them were ways the daily posting limit could be slipped past. One

Clear a corner of your workbench and gather a handful of parts, because this palm-sized television is an afternoon build, not a semester project. Here is the shopping list for a Scanwheel of your own: A Raspberry Pi Pico to run the show An A4988 stepper driver A 21-02485 stepper motor (or a similar small NEMA-style unit) Five LEDs, plus current-limiting resistors A 3D-printed case and spinning disk The Scanwheel, built by a maker who goes by [Ancient], is a mechanical TV that fits in your hand. Instead of a glowing panel, it leans on persistence of vision: your eye holds each flash of light for a fraction of a second, so a row of blinking LEDs seen through a moving slit reads as a solid picture. Spin the disk fast enough and the flicker melts into an image. How the picture actually forms The disk sitting on top of the case carries 20 small holes spaced evenly around its edge, each drilled at a slightly different height. As the motor turns, only one hole passes in front of the LEDs at a time, so light escapes in a scanning line rather than a wash. The Pico drives the stepper up to roughly 900 RPM through the A4988, then fires the LEDs in a precise order timed to the disk position. Get that timing right and the holes trace out a grid. The payoff is a 20x20 pixel color display in the center, flanked by two more 20x20 black-and-white panels that can each show a different image. Five LEDs feed all three. The whole coordination job lives on the Pico's GPIO pins, which is why the wiring stays simple enough to manage on a breadboard before you commit anything to a soldered protoboard. Small light baffles in the base keep the LEDs from bleeding into each other, a detail worth copying if your first image looks smeared. Give it a spin The full build guide, firmware, and disk files are on the project's GitHub repository , so you can match the hole spacing and LED timing exactly. If your image drifts or tears, start by trimming the RPM and re-checking when each LED switches rela

Hello everyone, I am currently building a high-performance API gateway that integrates business logic components—implemented via WASI and running within Wasmtime—as HTTP/TCP/QUIC handlers. I am exploring the best design approach to achieve a zero-copy data path from the upstream network layer—specifically hyper for HTTP/1.x and HTTP/2, and h3-quinn (based on Quinn) for HTTP/3—to the wasi:http guest environment. Given that: hyper and h3-quinn each manage their own internal buffer pools (e.g., bytes::Bytes ), asynchronous read/write streams, and frame decoders. Wasmtime's wasmtime-wasi-http implements the wasi:http (WASIp2) specification, which relies on resource types such as InputStream and OutputStream . I aim to minimize memory copying and CPU overhead when passing large request bodies or streaming responses across the sandbox boundary. For those experienced with bridging I/O between the host and guest in Wasmtime, I have a few architectural questions: Buffer ownership and memory mapping: How can host-side bytes::Bytes (from hyper or h3-quinn ) be mapped or bridged into Wasm linear memory (and vice versa) without requiring a CPU-based memcpy ? Does Wasmtime's resource streaming support direct memory views, or are we essentially limited to copying data chunks via guest memory pointers? Adapting stream abstractions: hyper uses http_body_util::combinators / http_body::Body , h3 uses its own stream primitives, while wasi:http uses wasi:io/streams . What is the idiomatic way to efficiently adapt these asynchronous streams on the host side (i.e., within the wasmtime-wasi-http handler implementation) without blocking the tokio runtime? Backpressure propagation: How can backpressure signals be correctly propagated from the Wasm guest (e.g., when the guest's InputStream is consuming data slowly) all the way back to the Quinn congestion controller or Hyper connection pool, thereby avoiding unbounded buffering on the host side? If anyone has built similar high-performance ga

இன்னும் ஜோஷ்! 🔥 முதல் நாள் St. Joseph's Institute of Technology, சென்னையில ஜோர்தான் இருந்தது. இரண்டாம் நாள் வந்ததும் என்னன்னா, க்ரவுட் இன்னும் அமைதியா, ஆனா உள்ள ஆர்வம் இன்னும் ஜாஸ்தியா இருந்துச்சு. எல்லாரும் "இன்னிக்கி ரொம்ப tech-ஆ போகணும்" னு மனசுல வெச்சிட்டு உட்கார்ந்திருந்தாங்க. இண்டு "தமிழன் நினைச்சா முடியாதது இல்ல" ங்கிற வார்த்தை என் மனசுல ஓடிக்கிட்டே இருந்தது — ஒரு சின்ன அறையில கூட, கம்ப்யூட்டர் screen-ல open source code-ஐ பார்த்துக்கிட்டே இருந்தா, அது எவ்ளோ பெரிய புரட்சின்னு தெரியும். FOSS-ன்னு சொல்ற ஒவ்வொரு லைனும், நம்ம மொழியில நம்ம கம்யூனிட்டியால எழுதப்படுற ஒவ்வொரு code-உம் ஒரு சிறிய வெற்றி தான். Session 1: வேகமா App கட்டணுமா? Meet Framework இருக்கே! 🚀 முதல் session-ல Meet Framework அறிமுகமானது — Python + JS ரெண்டையும் சேர்த்து ஒரே கூரையின் கீழ கொண்டு வர்ற ஒரு full-stack framework. இது என்ன பண்ணுது தெரியுமா? "Setup fatigue" ங்கிற பெரிய பிரச்சனையை ஒரே அடியில தீர்க்குது. Backend, frontend, database எல்லாத்தையும் தனித்தனியா தேடி, ஒட்டி, configure பண்ணி — இதெல்லாம் இல்லாம, ஒரே framework-ல எல்லாமே ready-ஆ இருக்கும். Speaker live-ஆ ஒரு app-ஐ கட்டி காமிச்சாங்க — routing, models, ஒரு simple UI எல்லாம் நிமிஷங்களில ready! அது பார்க்கும்போதே ஒரு எனர்ஜி கிடைச்சது. "Idea இருந்தா போதும், tool நம்ம கூட இருக்கு" ங்கிற நம்பிக்கை தான் FOSS-ன்ற அழகே. சின்ன Motivation: ஒரு framework கத்துக்கிறதும், ஒரு புது மொழி கத்துக்கிறதும் ஒண்ணுதான். ஆரம்பத்துல கஷ்டமா தான் தெரியும், ஆனா ஒரு அடி எடுத்து வெச்சா, மொத்த பாதையும் தெளிவா தெரியும். "தொடங்குறது தான் பாதி வெற்றி!" Session 2: NPM vs NixOS — ஒரு "Love-Hate" Relationship 😅 இரண்டாவது session ரொம்ப relatable-ஆ இருந்தது — NixOS-ல npm use பண்றது! அறையில இருந்த பலருக்கும் இது தெரிஞ்ச பிரச்சனை தான், எல்லாரும் தலையாட்டிட்டே இருந்தாங்க. பிரச்சனை என்னன்னா — Nix ரொம்ப strict-ஆ இருக்கும், file system-ஐ read-only-ஆ வெச்சிருக்கும். அதனால npm சாதாரணமா install பண்ற மாதிரி இங்க straight-ஆ வேலை செய்யாது. Speaker மூணு வழிகள் சொன்னாங்க: Local user prefix வெச்சு — npm-ஐ ஒரு writable இடத்துல install பண்ண வைக்கிறது. node2nix use பண்ணி — npm dependencies-ஐ

A Beijing startup just out-shipped every US lab's open-weight strategy On July 16, Moonshot AI — the Alibaba-backed startup behind Kimi — put Kimi K3 behind an API. Today, July 27, the full weights land on Hugging Face. No waitlist, no "responsible scaling" essay, no six-month delay between "we built something scary" and "here, run it yourself." Just 2.8 trillion parameters, open, on the day they said it would happen. That's not a small model with a big number attached. It's the largest open-weight model ever released, full stop. And unlike most "open" releases that quietly underperform their closed competitors, K3 is winning on the benchmarks developers actually care about. Let's get into what's real and what's marketing. The numbers K3 is a mixture-of-experts model: 2.8T total parameters, but it only activates 16 of 896 experts per token. That's the trick that makes a model this size runnable at all — you're not paying compute for the full 2.8T on every forward pass. The architecture story is Kimi Delta Attention (KDA), a hybrid linear attention mechanism Moonshot claims delivers 6.3x faster decoding, plus "attention residuals" that improve token efficiency by 25% for roughly 2% extra compute. Whether that holds up under independent scrutiny is still TBD, but the direction — make huge models cheap to serve — is the correct one, and it shows up in the token counts: K3 uses 21% fewer output tokens than its predecessor, K2.6, for comparable tasks. Context window: 1,048,576 tokens. Flat pricing, no context-length tiering — a real advantage over providers who quietly double your rate past 128K. Benchmarks that matter: Benchmark K3 Comparison Frontend Code Arena 1679 Elo (#1) Claude Fable 5: 1631, GPT-5.6 Sol: 1618 GPQA Diamond 93.5% Best open-weight score ever published GDPval-AA v2 1687 (#3) Behind Claude Fable 5 Max (1815), GPT-5.6 Sol Max (1747.8) — ahead of Claude Opus 4.8 (1600) Artificial Analysis Elo 1547 +732 over K2.6 Read that middle row again: an open-weight

AI coding tools have crossed a real threshold in the past year. Cursor and Windsurf count millions of active users. VS Code and JetBrains ship with built-in completion. Tencent Cloud demoed CodeBuddy NPC last month, where an agent takes a task spec, writes the code, opens a PR, runs CI, and fixes failures autonomously until everything goes green. You type a function signature and the model fills in a dozen lines before you finish thinking. Drop a comment saying "add unit tests" and a test skeleton appears in seconds. Individual coding speed is up somewhere between 3x and 5x by most team accounts. Pull the lens back from the editor to the team level and the picture changes. More code ships faster, but review queues grow longer, test environments get locked more often, and wait times between handoffs actually stretch out. A developer spends 20 minutes writing a feature, waits two hours for review, fixes comments, pushes again, and the staging environment is busy. QA posts failures in the group chat and the developer misses the message while on something else. Hours pass. Actual coding time might account for a tenth of the total delivery cycle. The rest is coordination, waiting, messaging, and context switching. The faster code gets written, the more congestion piles up behind it. The single-agent loop that products like CodeBuddy NPC demonstrate works cleanly for isolated work: one agent plans, codes, tests, and fixes until it passes. But any non-trivial feature in a real team crosses multiple roles. PMs confirm requirements. Tech leads do architecture reviews. QA runs regression in staging. Ops checks resource configs before deploy. Between each handoff today, someone pings Slack saying "PR up for review," drags a ticket from In Dev to Ready for QA in Jira, or scrolls through doc history trying to remember what came up in the last review. The agent can write the code, but it has no idea who to ping for review, how to provision a test environment, or why the last vers

The Go pod is running in production. CPU limit set to 2, metrics look reasonable. But under load, P99 latencies spike intermittently with no obvious cause. No errors, no goroutine leaks, just latency blowing up on traffic bursts. The root cause is usually invisible: GOMAXPROCS equals the number of CPUs on the physical node, not the container limit. Your Go app thinks it has 32 CPUs when it only has 2. The Linux kernel handles the gap in its own way — CFS throttling. What GOMAXPROCS reads (and what it ignores) By default, the Go runtime computes GOMAXPROCS via runtime.NumCPU() , which reads the number of CPUs available at the OS level. On a 32-core Kubernetes node, that returns 32 — regardless of what resources.limits.cpu says in your pod spec. Kubernetes CPU limits are enforced through Linux cgroups (v1 or v2). Cgroups are transparent to processes: a pod with limits.cpu: "2" doesn't see two virtual CPUs, it sees all the node's CPUs and gets suspended when it consumes too much. The Go runtime, historically, never read cgroups. It trusted the physical core count. package main import ( "fmt" "runtime" ) func main () { // Inside a pod with limits.cpu: "2" on a 32-core node fmt . Println ( runtime . NumCPU ()) // → 32 fmt . Println ( runtime . GOMAXPROCS ( 0 )) // → 32 } CFS throttling: how the kernel slows you down The Linux CFS (Completely Fair Scheduler) enforces CPU limits via two cgroup parameters: cpu.cfs_quota_us (allowed CPU time) and cpu.cfs_period_us (measurement window, 100 ms by default). A pod limited to 2 CPUs gets at most 200 ms of CPU time per 100 ms window. When Go spawns 32 OS threads for 32 parallel goroutines, those threads compete for physical CPUs. Once their combined usage exceeds the cgroup quota within the current window, the kernel suspends all threads in the cgroup until the next window starts. That's throttling: a complete application freeze lasting anywhere from a few milliseconds to several tens of milliseconds. A handful of these per second

Black holes eject powerful energy jets that blow away the surrounding gas to great distances. So how can they continue to grow?

I tested the Soundcore Nebula P1i, an affordable projector, to see if it could overcome the typical drawbacks that most budget projectors suffer from.

A place to trade small favors instead of money. Post a skill ("I can fix spreadsheet formulas," "I'll practice beginner Spanish with you"), say how many minutes it takes, and swap it for someone else's time. No payments anywhere in this app, on purpose - the whole point is that minutes are the currency. If you guys like this app please follow https://github.com/Timinesh/ submitted by /u/comradetiminesh [link] [留言]

How to design, ship, and operate an AI agent that is reliable, efficient, performant, scalable, and secure enough to serve real companies — from a 5-person startup to a 50,000-person enterprise. This guide distills hard-won lessons from production agents (Claude Code, OpenHands, SWE-agent, GoClaw, Hermes, nanobot, PicoClaw, ZeroClaw, Multica, Paperclip) and grounds them in current engineering guidance from Anthropic and OpenAI plus the security and compliance standards you'll actually be audited against (OWASP Top 10 for Agentic Applications, NIST AI RMF, the EU AI Act, and 2025–2026 prompt-injection research). It focuses on the parts most articles skip: the enterprise tax — governance, security, compliance, integration, cost control, and the operating model — that separates a demo from a system a CISO will sign off on. 📖 How to use this guide Read Parts 0–2 to decide whether and what to build. Most failed agent projects die here. Read Parts 3–7 for the architecture and reliability engineering. Read Parts 8–10 for the enterprise gates: security, compliance, multi-tenancy, observability, cost. Read Parts 11–15 for delivery, scale & rollout: deployment topologies (SaaS/self-hosted/hybrid), how to adopt from pilot to org-wide, how to handle thousands of concurrent requests, the operating model, and a 30/60/90 plan. Every part ends with an ✅ Actionable checklist . Skim those for a design review. 📋 Table of Contents 🧮 Part 0 — The Core Equation 🧭 Part 1 — Decide Before You Build: Workflow vs Agent, Build vs Buy 🏛️ Part 2 — The Enterprise Tax: What Actually Changes 🏗️ Part 3 — Reference Architecture: The Layered Stack 🔄 Part 4 — The Reliable Kernel: The Agent Loop 🛠️ Part 5 — Tools & Enterprise Integration 🧠 Part 6 — Context & Memory: The Cost Center 🛟 Part 7 — Reliability Engineering 🔐 Part 8 — Security, Compliance & Governance 🧱 Part 9 — Multi-Tenancy & Isolation 📊 Part 10 — Observability, Evals & Cost Governance 🚀 Part 11 — Deployment & Delivery Models 📈 Part 12 — The

AppleCare insurance for multiple devices including iPhones, Watches and MacBooks, is finally expanding outside the US.