标签：#ai

UN panel says 'AI is neither inherently good nor bad,' but better safeguards around it are needed.

Rhythm Heaven isn't Nintendo's best-known series, nor its most prolific. Prior to the launch of Rhythm Heaven Groove on the Switch this week - it's out on July 2nd - there were only four previous entries, one of which was exclusive to Japan. The most recent came out more than a decade ago. Even still, […]

Smart speakers have spent the past few years searching for a compelling second act. Beyond music, timers, and controlling your lights, they've struggled to justify taking up space on the kitchen counter. AI promised to change that. Amazon debuted its new hardware powered by a revamped Alexa last fall, and now it's finally Google's turn. […]

Getty Images has moved to terminate a $3.7 billion merger with rival Shutterstock due to restrictions imposed by UK regulators.

If you've submitted a BOM for quoting recently and gotten a lead time that made you do a double take, you're not imagining things. Passive component sourcing in 2026 is tighter than it's been in a few years — and MLCCs are the epicenter. I want to break down why this is happening, which component categories are actually at risk, and — more importantly — what you can do at the design stage to make your board less vulnerable to it. This isn't a "just wait it out" post; there are concrete layout and BOM decisions that meaningfully change your exposure. Why now? Three demand sources are converging on the same MLCC/inductor capacity that used to be dominated by consumer electronics: AI server infrastructure — GPU power delivery networks alone can chew through hundreds of decoupling capacitors per board, and hyperscaler order volumes dwarf typical consumer runs. EVs — automotive-grade passives (AEC-Q200, X8R/X7R) come from a narrower qualified supplier base, so even modest EV growth disproportionately tightens that segment. Renewables/grid infrastructure — pulling on high-voltage inductors and power resistors. On the supply side, new MLCC/ferrite production lines take 12–24 months to come online from the capital decision. Semiconductor fabs can reallocate capacity relatively fast; passive component fabs can't. That structural lag is the real reason lead times stretch out faster than they recover. Which parts are actually at risk Not everything is equally exposed: Category Normal LT 2026 Tight-Market LT Exposure Commercial MLCC (X7R, 0402/0603) 4–8 wks 8–16 wks Moderate–High High-density MLCC (0201, high µF) 6–10 wks 16–26 wks High Automotive MLCC (AEC-Q200, X8R) 10–14 wks 20–30+ wks Very High C0G/NP0 (precision/timing) 4–8 wks 6–12 wks Low–Moderate Power inductors (shielded, low DCR) 6–10 wks 12–20 wks Moderate–High Chip resistors 2–6 wks 4–8 wks Low Chip resistors are the least affected — manufacturing capacity is less concentrated and swapping vendors doesn't trigger a

Here's a scenario that plays out in engineering teams every day: you spin up a conversation with an AI tool to analyze some code, get a useful response, copy-paste the output, and close the tab. An hour later, you need a follow-up analysis — and you're starting from scratch. No context, no history, no continuity. Now multiply that by five tools running in parallel. ChatGPT for drafting, Claude for analysis, Copilot for code, a local model for sensitive data, maybe a custom agent for domain-specific tasks. The outputs are scattered across browser tabs, Slack threads, and clipboard history. Nothing connects. The AI tools themselves are capable enough. What's missing is the infrastructure to treat them as actual team members — with identities, workspaces, and accountability. The Identity Problem Every AI interaction today is anonymous. You talk to "the model," it responds, the session ends. There's no persistent identity, no accumulated context, no track record. This works fine for one-off questions. It breaks down the moment AI needs to participate in a sustained workflow — the kind where you need to know who did what, when, and how well. We've been building an open-source project called Octo (Apache 2.0, GitHub ) that approaches this problem by giving AI agents a proper identity system. In Octo, each AI agent is a Bot — a first-class entity with a name, a creator, a capability card, and a work history. A Bot isn't a chatbot wrapper. It's a structured identity: Creator binding : Every Bot is created by a human user and inherits a scoped subset of that user's permissions. The Bot acts on behalf of its creator, not autonomously. AgentCard : A structured capability declaration — what the Bot can do (coding, analysis, translation, design), at what level, in what domains, and with what constraints. Think of it as a resume that other team members can inspect before assigning work. Work history : Every task a Bot participates in gets recorded — completion status, quality sco

This week was largely a Claude story: Sonnet 5 landed with enough benchmark muscle to make Opus feel redundant for most workloads, and GitLab's production data backs up the claims. Alongside that, GitHub Copilot quietly dropped its JetBrains friction, and Google's image model got cheaper and faster on Vercel's gateway. Here's what's worth acting on. Claude Sonnet 5 launches on Vercel AI Gateway Sonnet 5 is available now via Vercel AI Gateway at anthropic/claude-sonnet-5 . Launch pricing is $2/$10 per million input/output tokens—identical to Sonnet 4.6—but that rate expires August 31, after which it steps to $3/$15. The model matches Opus 4.8 on coding and agentic benchmarks, which means you can stop routing hard tasks to Opus and absorb a 50–67% cost reduction in the process. For AI SDK users, this is a one-line change. Stronger long-context handling and document parsing are the practical wins for RAG pipelines and multi-turn agent workflows—two areas where Sonnet 4.6 had real rough edges. Verdict: Ship. Update your model identifier before August 31 while the launch pricing holds. Zero breaking changes, and there's no reason to stay on 4.6 for new work. Sonnet 5 closes Opus gap at lower cost Beyond the Vercel integration, the broader Sonnet 5 release deserves its own read. The model is now the default reasoning tier replacing Sonnet 4.6 across Anthropic's plans, and the capability jump is specifically on agentic task completion—planning, multi-step tool use, brownfield code navigation. Early testers report that tasks which previously stalled midway through agent loops now finish end-to-end, which is a qualitatively different outcome from incremental benchmark gains. The economics are straightforward: Opus-level performance at Sonnet prices through August, then a modest step up to $3/$15. If you're running production agents today, the cost-per-completed-task improvement compounds because you're paying less and spending fewer cycles on failure recovery and re-promptin

TL;DR codegraph , codebase-memory-mcp , and serena all got there first, handing a coding agent code intelligence over MCP so it stops grepping. On my own open-ended questions the token bill didn't budge: the agent kept sliding back to grep, and no amount of forceful prompting could stop it. So I built @ttsc/graph . It gives the agent an index the TypeScript compiler already resolved, never the source bodies, through a single tool with a forced chain-of-thought. On "how does this work?" questions that works out to roughly 10× fewer tokens, and the answers are no worse. That figure is a median, and a conservative one. Repository: https://github.com/samchon/ttsc Benchmark: https://ttsc.dev/docs/benchmark/graph 1. Preface 1.1. What @ttsc/graph Is On the left, the agent is lost in a maze of files, chasing dashed arrows dozens deep. On the right, it's reading a single compiler-built graph of nodes and edges, with the file:line anchors it can open and check. You're new to a TypeScript repo, so you ask the agent for a tour: what's the main runtime flow, from the public API down to the code that does the work, and what should you read first? You know how it goes. It opens a file, follows an import into another, then another, and a few dozen files later it gives you an answer. @ttsc/graph cuts that crawl short. Over MCP, it hands your agent a graph of your TypeScript codebase that the compiler itself drew: what calls what, what depends on what, and where each piece lives. The agent answers structural questions straight from the graph instead of spelunking through files, and every claim it makes points at an exact file:line the compiler resolved. Nothing invented, just a location you can open and check for yourself. It's the same question and the same agent in every case, and only @ttsc/graph stays flat across the repos no matter how big they get. The other three, codegraph, codebase-memory, and serena, swing all over the place, and a few even spend more than the baseline does

Pernah kepikiran, "Sebenarnya AI agent saya inget apa aja sih soal saya?" Kalau iya, tulisan ini buat kamu. Masalahnya: Memori AI Itu Kotak Hitam Kalau kamu pakai AI agent yang punya memori jangka panjang (persistent memory), kamu mungkin pernah ngerasa gak nyaman karena beberapa hal ini: Gak tahu persis apa yang diingat AI tentang kamu Gak tahu file-nya disimpan di mana Gak bisa edit memori itu tanpa ngetik perintah lewat chat Takut kalau file memorinya rusak, semua informasi hilang begitu saja Studi kasus di tulisan ini pakai Hermes Agent , agent open-source besutan Nous Research. Sebagai konteks buat yang belum familiar: Hermes Agent adalah agent AI open-source yang berjalan sebagai proses (daemon) mandiri di server milikmu sendiri, mengumpulkan memori lintas sesi, menjalankan tugas terjadwal, terhubung ke belasan platform pesan, dan menulis skill-nya sendiri dari pengalaman. Framework berlisensi MIT ini dirilis Februari 2026 dan dengan cepat menarik perhatian komunitas open-source AI. Hermes menyimpan memorinya di dua file utama: USER.md (profil tentang kamu) dan MEMORY.md (catatan agent soal lingkungan kerja, kebiasaan, dan pelajaran yang dipetik), plus satu file lagi SOUL.md untuk "kepribadian" si agent. Semuanya disimpan dalam format teks polos yang dipisah pakai karakter § , seperti ini: Preferensimu: komunikasi singkat dan langsung § Namamu Budi, awal 30-an, tinggal di Surabaya § Penggemar PKM / Building a Second Brain Format ini fungsional, tapi ada beberapa kekurangan: Susah diedit langsung karena bukan format yang ramah manusia Gak ada riwayat versi — sekali salah edit, informasi bisa hilang selamanya Gak ada tampilan visual — susah lihat semua catatan sekaligus Gak ada antarmuka grafis — harus lewat chat agent atau edit file mentah Solusinya: pindahkan memori itu ke Obsidian , aplikasi catatan berbasis markdown yang mendukung riwayat versi lewat git dan bisa diedit bebas. Arsitektur Sistemnya Sistem sinkronisasi ini punya empat lapisan: ┌───────────────

An AI feature can feel impressive and still be a bad product decision. The demo is fast. The answer sounds useful. The team is excited. Then usage grows and nobody can answer the basic questions: Is it accurate enough? Is it saving time? Which customers trust it? Why did costs spike? Should we scale it, fix it, or kill it? That is the trap an AI metrics baseline prevents. A baseline is not a dashboard full of vanity charts. It is a small set of before-and-after measurements that tells you whether an AI workflow is getting better, getting worse, or merely getting more expensive. Why AI features fail without a baseline Most software teams already track uptime, errors, and conversion. AI features need those too, but they also need new signals because model behavior is probabilistic. A normal API either returns the expected response or throws an error. An AI workflow can return: a fluent answer that is wrong a correct answer with missing evidence a useful answer that costs too much a slow answer that users abandon a safe answer that refuses too often a cheap answer that hurts trust a high-rated answer that does not improve the business workflow Without a baseline, every production discussion becomes opinion-driven: "The model seems better." "Users like it." "The new prompt reduced hallucinations." "The expensive model is worth it." Maybe. Maybe not. The baseline turns those claims into measurable comparisons. What an AI metrics baseline is An AI metrics baseline is the starting measurement for the workflow before you optimize or scale it. It answers five questions: What does the workflow cost today? How good are the outputs today? How fast and reliable is the experience today? Do users adopt and reuse it? Does it improve the real task it claims to improve? You do not need 80 metrics on day one. You need a small set of metrics that match the feature's risk and purpose. For example: Feature Useful baseline Support answer bot resolution rate, citation quality, escalation r

While researching the massive wave of digital transformation rewriting the rules for startups this year, I stumbled upon an insightful podcast by the tech firm GeekyAnts. Hosted by Prem, the episode featured Sanket Sahu, the co-founder of GeekyAnts, who recently emerged from a year and a half hiatus to discuss what he calls the " AI-native shift ." As someone navigating the unpredictable US tech market in 2026, listening to their conversation felt like a reality check. We are constantly flooded with news about AI replacing engineers or cutting budgets, but this discussion offered a grounded perspective on what is actually happening on the ground in software development. The Illusion of Speed The central theme that caught my attention was the sheer velocity of modern AI adoption. Sanket made a striking contrast: while television took decades to become a common household utility, modern AI systems like ChatGPT or Claude reached exponential revenue and widespread adoption in mere months. But here is where the critical analysis kicks in. As founders, we often mistake engineering speed for product success. The podcast highlighted a massive bottleneck that many of us are guilty of overlooking: the human limit. While AI can spin up code in hours instead of months, the time required for human review, validation, and team collaboration remains relatively static. If an organization rushes to ship code simply because it can, they risk launching products that lack deep market validation. True product development still requires user testing and meticulous iteration. The building phase might be operating at 10x speed, but the surrounding human infrastructure is only moving at 1.5x. Fluid Roles and the Rise of the "Builder" Another significant takeaway for Western businesses is the shifting definition of software roles. The traditional silos dividing front-end, back-end, and DevOps are rapidly blurring. According to the insights shared in the video, the engineering ecosystem is mo

Meta's Conversation Focus feature for smart glasses is now only free for three hours a month.

We all use AIs today - From a 5th grader to a retired pensioner, from a small-time business owner to a multimillionaire businessman, from a software engineer to a medical expert. AI exists everywhere! And to be honest its making our lives very simple. Yes, it does!. Response in no time, flexibility, reliability - yes, AI gives all and even more And as Software Engineers, we are getting more inclined towards AI. Back in the days, we used to rely on Stackoverflow to get our queries resolved. Sometimes it did, sometimes it didn't. But, AI changed that landscape completely - asking a query, retrieving data, asking follow-ups and so and on so forth. But, honestly, how many of us have thought - Wow this looks amazing! But how does it actually work! Let's say I type this in Chat GPT or Gemini or Claude etc: "Hi, how is the weather today?". The AI assistant takes the input and processes it and returns the response. But , there is a lot of processing and workflow happening under the hood. As a Software Architect, I struggled a lot to get these answers. Different sources, different suggestions. And the suggestions at some point seemed too overwhelming for me. So, I decided to break it down and start a series which will enable people to understand AI. I want to make people understand AI in the simplest way possible and make every developer leverage AI - not just to get their job done, but also to help in upskilling, so that they don't get lost in the overwhelming world of AI as I did initially! Follow me for more updates!

Fable is back. The Commerce Department announced yesterday it has lifted the export controls it...

Look at tomorrow's track list and count the rooms that have absolutely nothing to do with...

I’m at the AI Engineer conference in San Francisco this week. The event has every major brand-name...

I’ve been covering Warp for a couple of years now, and its rapid evolution from a command-line...

The Problem LLM evaluation tools like Patronus AI excel at hallucination detection, toxicity checks, and semantic relevance. But they don't catch the structural failures: A JSON response missing required fields A function call with malformed parameters Output that violates schema constraints Latency budget overruns silently degrading UX Cost explosions from runaway token usage These aren't hallucinations. They're verification failures. The Solution correctover-patronus is an adapter that runs Correctover's 87 deterministic verification rules as native Patronus evaluators. Every verdict comes with a recomputable proof hash — meaning you can verify the verifier. pip install correctover-patronus The 6 Dimensions Dimension What It Checks Example Structure Output format validity JSON parses correctly Schema Field presence & types Required fields exist Identity Semantic relevance to input Response addresses the question Integrity Forbidden pattern absence No Tracebacks or error messages Latency Response time budget Under 30s threshold Cost Token usage budget Under 10k token limit Usage Full 6-Dimension Verification from correctover_patronus import CorrectoverEvaluator , CorrectoverConfig config = CorrectoverConfig ( min_confidence = 0.7 , latency_rules = { " max_ms " : 5000 }, cost_rules = { " max_tokens " : 4000 } ) evaluator = CorrectoverEvaluator ( config = config ) result = evaluator . evaluate ( task_input = " Summarize this article... " , task_output = " The article discusses... " , task_context = { " source " : " article " , " word_count " : 1500 } ) print ( f " Overall: { result . score : . 2 f } ( { ' PASS ' if result . pass_ else ' FAIL ' } ) " ) print ( f " Proof hash: { result . metadata [ ' proof_hash ' ] } " ) for dim , info in result . metadata [ ' dimensions ' ]. items (): print ( f " { dim } : { info [ ' status ' ] } (score= { info [ ' score ' ] : . 2 f } ) " ) Individual Dimensions from correctover_patronus import correctover_structure , correctover_inte

How We Process 7,500 Product Images Daily Without Breaking the Pipeline A behind-the-scenes look at the technical workflow that keeps eCommerce image editing consistent at scale — and what breaks when you try to fully automate it. We process over 7,500 product images every single day. When you're running at that volume, even a 2% error rate means 150 broken images going out to clients' Amazon listings, Shopify stores, and product catalogs. A 2% error rate at that volume is a business problem, not a rounding error. This post is about what we learned building a pipeline that handles that volume reliably — the parts that automated well, the parts that didn't, and the specific technical decisions that made the difference. If you're a developer building an eCommerce image processing workflow, or a technical founder trying to figure out how to scale product photo operations, this is the breakdown I wish I'd had earlier. The Core Problem With Fully Automated Image Processing Every developer who builds an image processing pipeline goes through the same arc. Phase 1: "AI background removal is incredible. I'll automate everything." Phase 2: "Why are 30% of these outputs rejected by Amazon?" Phase 3: "Why is my client's return rate going up?" Phase 4: "I need to add human review back in. But where?" The issue isn't that AI image processing is bad. It's that it's inconsistent in ways that are difficult to detect automatically — and the failures that matter most are the ones that look fine at thumbnail resolution but fail at 1:1 zoom or fail RGB verification. Here's what a naive automated pipeline misses: # What developers think background removal does: result = ai_remove_background ( image ) # Returns: clean product on transparent background # What actually happens on complex products: # - Jewelry chains: partial removal, missing links # - Fabric with lace: holes in the garment, not the background # - Transparent products: product partially removed # - Products matching backgro

An agent opened a pull request on our service last week. Six hundred lines. It rewrote how we handle webhook retries and deduplication, an area that is fiddly and easy to get subtly wrong. The diff was clean. The tests were green. The commit messages were better than mine usually are. And I felt the specific dread that I think a lot of engineers are starting to feel in 2026. I was the reviewer. I had not written any of this. I had no idea why it was shaped the way it was. To review it properly, the way I would want my own code reviewed, I was looking at the better part of an hour of carefully reconstructing intent from the code itself. I did not have that hour. So I did what almost everyone does in that situation, which is skim it, decide it looked reasonable, and approve. That moment is the actual problem with AI-written code, and it is not the one people argue about. The bottleneck moved, and most teams have not adjusted The tired debate is whether agents write good code. In 2026 that argument is mostly over. They do. They plan, they read the codebase, they run the tests, they back out of dead ends, they open pull requests that clear most review bars. If you are still litigating whether the code is any good, you have not used a current agent in a while. But here is what follows from that, and it is the part teams have not absorbed: if writing the code is no longer the slow step, then reviewing it is. And review does not scale the way generation does. An agent can produce five well-tested pull requests before lunch. Your senior engineers cannot deeply review five pull requests before lunch, not on top of their own work. The volume went up and the review capacity did not, and something has to give. What gives is the depth of review. It degrades, quietly, into a skim. People approve fluent diffs they have not truly read, because reading them properly costs more time than anyone has. The green check still appears. It just means less than it used to. That is a governan