标签：#ai

The assumption every RAG demo makes Standard RAG assumes the user's question maps onto one vector search. One query in, one embedding, one top-k lookup, one answer. That assumption holds up in demos, because demos ask demo questions. "What's our parental leave policy?" is one document. Retrieve it, stuff it into the prompt, done. Then you ship, and a real user types: "Did the carrier rate change we approved in Q2 actually reduce our cost per shipment in the Northeast, and does that hold if I exclude the Boston depot?" That question needs a policy document, a rate table, a transactional aggregate, and a filtered re-computation. Your retriever will embed the whole sentence, find the three chunks nearest to it in vector space, and hand the model text that is topically adjacent and factually useless. The model, being a good sport, will answer anyway. The problem isn't the embedding model or the chunk size. You hardcoded how many times to retrieve, and where to retrieve from, at design time, for a question you hadn't read yet. Agentic RAG moves that decision to runtime. Planners, memory, MCP servers, sub-agents: all of it is implementation detail hanging off that one change. Architecture 1: standard RAG is a straight line STANDARD RAG — fixed pipeline, one pass ┌──────┐ 1. prompt+query ┌─────────────┐ │ User │ ───────────────────► │ Chat UI │ └──────┘ └──────┬──────┘ ▲ │ 2. query │ 6. response ▼ │ ┌─────────────┐ │ │ Retriever │ │ └──────┬──────┘ │ │ 3. fetch (top-k, one shot) │ ▼ │ ┌───────────────────────────┐ │ │ Knowledge Sources │ │ │ docs · PDFs · code · DB │ │ │ APIs · web index │ │ └───────────┬───────────────┘ │ │ 4. chunks │ ┌──────▼──────┐ └──────────────────────────│ LLM │ └─────────────┘ 5. prompt + query + enhanced context The defining property is that the model is never consulted about retrieval. It receives context and produces text, and retrieval already finished by the time it runs. That's a design choice with real advantages. One embedding call plus on

Caterpillar has spent decades putting autonomous machines to work at remote mining sites. It's now bringing that experience to AI deployment.

Smart TVs store lots of data, and the amount they have to work with is often quite low. There are ways to maximize your storage space, though.

Chess.com has done one thing, and one thing very well, for almost 20 years, but now it's going beyond its domain name. The biggest name in online chess quietly launched its first companion site in beta back in May: Gambit, a free online poker website where players can learn the game without risking any real […]

AI agents are good at interpreting goals, but prose instructions are a weak place to enforce exact rules. If a skill says "keep the commit subject short" or "never commit without approval," an agent can still misunderstand the boundary. The open-source how-to-create-a-skill-tutorial shows a practical split: let the agent make judgments, and let small local scripts validate repeatable rules. This tutorial builds the smallest useful version of that pattern: a commit-crafter skill with a SKILL.md file, a Python validator, and tests that run with the Python standard library. TL;DR An Agent Skill is a directory containing at least SKILL.md . Put the workflow and safety boundaries in that file. Put exact validation in a script. Keep the script deterministic, return meaningful exit codes, and run it before presenting the result to a user. The finished repository's example skill validates Conventional Commit messages. You can copy the same structure for release notes, config generation, research reports, or any other workflow with rules that can be checked mechanically. Prerequisites You need: Python 3.12 or newer for the repository's CI example. Git if you want the skill to inspect staged changes. An agent that supports the Agent Skills directory convention. A shell. The commands below use POSIX syntax; the files themselves are also designed for Windows. The project has no stable release tag at the time of writing. The examples and commands below are checked against the current main branch. Read the Agent Skills specification if your client uses a different discovery directory. 1. Create the skill directory The repository documents two useful scopes. A personal skill belongs in your user skills directory. A project skill belongs in the repository so a team can review and install it with the project. mkdir -p .agents/skills/commit-crafter/scripts mkdir -p .agents/skills/commit-crafter/references The required layout is simple: commit-crafter/ |-- SKILL.md |-- scripts/ | `--

Live API specs for coding agents An agent writing frontend code has to know the backend's API. It has three options. It can read the backend source and work out from scratch what the service already publishes. It can ask you, which promotes you to API documentation. Or it can swallow the entire OpenAPI document in order to use one route out of it. Then it does the same thing again tomorrow, against a stale swagger.json you exported last week. docs-mcpserver takes the spec straight from the running service, caches it, and serves it one operation at a time. The config { "cacheDir" : "./cache" , "libraries" : [ { "name" : "orders-api" , "description" : "Order handling service" , "sources" : [ { "type" : "url" , "origin" : "https://localhost:5001/openapi/v1.json" , "kind" : "schema" , "name" : "orders" } ] } ] } npm install -g docs-mcpserver claude mcp add docs -- docs-mcpserver --config /path/to/dev-docs.json That is the whole setup. One operation, not the whole spec The agent lists the definitions in orders , picks the one it needs, and fetches that. For an OpenAPI document the path operations are exposed as definitions named GET /orders/{id} , so it can also search by keyword. A few hundred tokens for the operation it is writing against, instead of the entire document. That keeps working as the service grows, which a pasted spec does not. The backend does not have to be running Every call is answered from the cached spec, never from the network. The fetch happens on startup and then in the background while you work, so an endpoint you added 20 seconds ago is already visible. Start the backend once, shut it down, and keep building the frontend. The agent still has real routes and real payload shapes. If the service is down, or answers with something that is not a spec, the last known-good copy keeps being served. Code and issues: github.com/jgauffin/dev-docs-mcp . On npm as docs-mcpserver .

Anthropic opened a research preview of the Model Hardware Standard (MHS) on August 28, 2026 , describing it as a shared specification that allows AI agents to safely operate programmable physical devices used in scientific research and advanced manufacturing. The standard is intended to cover equipment such as microscopes, robotic systems, and other laboratory or industrial hardware. Anthropic's goal is to create a common interface so an agent doesn't need a completely custom integration for every physical device. Why It Matters: This is effectively an extension of the tool-calling model into the physical world. Most agent architectures today look like: User ↓ AI Agent ↓ Tool ↓ API / Database / SaaS ↓ Digital Action MHS points toward: User / System ↓ AI Agent ↓ Hardware Capability Interface ↓ Device Controller ↓ Physical Instrument ↓ Real-World Action The interesting part is the standardization layer. The same way HTTP allows applications to communicate without knowing the internal implementation of a server, a standardized hardware interface could allow AI agents to reason about capabilities rather than vendor-specific control systems. For example, an agent shouldn't need to understand every low-level command required by a microscope. Instead, it could interact with higher-level capabilities: capture_image() set_magnification() move_stage() measure_sample() The underlying device implementation handles the hardware-specific details. That creates a powerful architectural separation: Agent Reasoning ↓ Capability Contract ↓ Safety / Permission Layer ↓ Device Adapter ↓ Hardware But physical systems introduce a much higher safety requirement than ordinary software tools. If an AI agent makes a poor decision while generating text, the result may simply be incorrect. If an agent controls laboratory or industrial equipment, an incorrect action could damage equipment, waste materials, or create safety risks. That means future agent architectures will likely require stronger

How to combine exponential backoff, circuit breakers, and graceful fallbacks for production-grade agentic workflows. The Bottleneck in Production AI agents are only as reliable as the tools they invoke. When an LLM decides to search the web, scrape a URL, or fetch database records, it depends entirely on network stability. In production, external APIs fail constantly. A sudden surge causes 429 rate limits, a third-party microservice throws a 504 timeout, or a target endpoint goes down entirely. The naive approach—executing raw tool calls directly inside the agent loop—is a ticking time bomb: # The Naive Anti-Pattern: Fragile Tool Execution def execute_agent_tool ( tool_name : str , payload : dict ): # One 500 error here kills the entire multi-step reasoning chain response = requests . post ( f " https://api.service.internal/ { tool_name } " , json = payload ) return response . json () When this call breaks, the unhandled exception crashes the runtime. You lose the entire reasoning graph, waste LLM tokens, and degrade the user experience. The System Architecture: Layered Tool Defense To keep multi-step agents alive, you need a defensive execution pipeline wrapped around every tool. Instead of allowing errors to bubble up and kill the agent, we handle failures across three distinct layers: Exponential Backoff : Mitigate transient network glitches and minor rate spikes by retrying with increasing delays. Circuit Breaker : Detect persistent downtime. If an API fails three times consecutively, trip the breaker to stop sending doomed requests. Graceful Fallbacks & Partial Degradation : When a primary service is down, route the query to a replica, cached store, or lightweight fallback (e.g., cached search index instead of a live browser scrape). [ Agent Core ] │ ▼ ┌───────────────────────────────┐ │ Circuit Breaker Check │ │ (Is Primary Service Up?) │ └──────────────┬────────────────┘ OPEN │ CLOSED (Healthy) ┌───────┴────────┐ ▼ ▼ ┌─────────────┐ ┌─────────────────────────

Does Jalapeño beat NVIDIA? On the benchmark OpenAI published, yes. Does that make it a better chip than NVIDIA's Blackwell platform? The evidence does not support that claim yet. Should NVIDIA care? Yes. Jalapeño gives OpenAI a credible way to move repeated, high-volume inference onto hardware it controls. That changes how OpenAI buys GPUs, how much pricing power NVIDIA keeps, and how expensive it is to leave CUDA. That is a narrower claim than "NVIDIA killer." It is also more interesting. Short version: Jalapeño is an inference ASIC co-developed by OpenAI and Broadcom. Early results show excellent latency and performance per watt on three large models. It has not yet proved production-scale economics, long-context agent performance, or fleet reliability. Near term, it gives OpenAI capacity and negotiating power. Over time, it could take a profitable slice of inference away from merchant GPUs and weaken one part of NVIDIA's software moat. This is infrastructure analysis, not a stock call. What exactly is Jalapeño? OpenAI calls Jalapeño its first "Intelligence Processor." The plainer description is a custom ASIC for large-language-model inference, built with Broadcom and turned into boards, racks, and production systems with Celestica. This is intended to become more than a lab project. OpenAI and Broadcom announced a 10-gigawatt custom-accelerator program in October 2025, with racks targeted to start deploying in the second half of 2026 and the program running through 2029. Those gigawatts are a roadmap, not deployed capacity. The original collaboration announcement states the schedule . Inference is the part that happens after training. A model has already learned its weights. The system now has to process a prompt, generate tokens, maintain the conversation state, route requests, and repeat that work for millions of users and agents. NVIDIA GPUs can train models and serve them. Jalapeño has a smaller job description. It is designed around serving current and futur

Wrap the payment. It runs once across retries, crashes, resumes, and replays. exactly-once is a Python library that makes a side effect run a single time. Wrap the function that pays an invoice or sends an email, or submits a transaction and it executes once per key, then replays its stored result on every later call. Here is the whole integration: from exactly_once import once , Store , current_key store = Store . sqlite ( " effects.db " ) @once ( store , key = lambda inv , ** _ : f " pay: { inv . id } " ) def pay_invoice ( inv ): return payments . transfer ( inv . vendor , inv . amount , idempotency_key = current_key ()) Call pay_invoice(invoice) and it pays the vendor. Call it again from a retry, a resumed run, a replay, or a second worker and it returns the recorded result. The vendor is paid once. The crash it's built for An agent pays an invoice. The transfer reaches the provider and succeeds. The process dies in the moment between the provider's 200 OK and the line that records the result. The agent restarts and reaches the same step again. exactly-once writes a record the instant the agent enters the call. pay_invoice claims the key pay:{invoice.id} , and the store marks it IN_FLIGHT . When the result returns, the store marks it COMMITTED and saves that result. After the crash the record reads IN_FLIGHT with an empty result the library knows a payment started and holds no proof it finished. So it quarantines the key. The agent leaves that payment for a decision and moves on. You give @once a prober that asks the payments API whether a transfer with that idempotency key exists: the library commits the key when the provider confirms the payment, and releases it when the provider confirms none. Until an answer arrives, the held payment stays in the ledger where you can see it: store . list ( state = " in_flight " ) # every payment awaiting a verdict How the guarantee holds Three states, one atomic operation: FRESH ──claim──▶ IN_FLIGHT ──commit──▶ COMMITTED clai

After sixty-seven published posts here, the comments have become one of the best parts of the work....

The company is testing robots on tasks that can performed by technicians.

Hello, I'm Maneshwar, and I'm building LiveReview — a blast-radius aware AI code review built for...

Thin vs Thick Provisioning: Which One Is Actually Eating Your Datastore? You just got an alert: your datastore is at 92% capacity. But when you check the actual VMs, they're barely using half the storage you allocated to them. Welcome to the most common source of confusion in virtualization storage — the gap between allocated and used . This comes down to how you provisioned your virtual disks in the first place. Thin Provisioning: Pay As You Go With thin provisioning, a 100 GB virtual disk doesn't actually consume 100 GB on your datastore right away. It grows as data is written to it. Create ten VMs with 100 GB thin disks, and if they're only using 20 GB each, your datastore shows 200 GB used — not 1 TB. This is why thin provisioning is the default choice for most environments today. It lets you overcommit storage and squeeze more VMs onto the same physical hardware. The catch: you must monitor actual datastore consumption, not just allocated capacity. If every VM suddenly starts writing more data than expected, you can run out of physical space even though your dashboards showed "plenty of room" based on allocated sizes. Thick Provisioning: Reserve It All Up Front Thick provisioning reserves the full disk size the moment you create it. There are two flavors: Lazy-zeroed : space is reserved, but blocks are only zeroed out the first time the VM writes to them. Faster to create, slightly slower on first write. Eager-zeroed : every block is zeroed at creation time. Slower to provision (a 500 GB disk can take a while), but delivers the most predictable, consistent I/O performance from the very first write. Which One Should You Actually Use? A simple rule of thumb: default to thin provisioning for general-purpose VMs — web servers, file servers, domain controllers, dev/test environments. Switch to eager-zeroed thick provisioning specifically for workloads where I/O consistency matters more than storage efficiency — databases, latency-sensitive applications, anything whe

AI coding agents have a communication problem. They can be technically capable and still make a development loop feel slow because every small action arrives with a paragraph of ceremony: a restatement of the ticket, a promise to investigate, an explanation of an obvious command, and a summary that repeats the first three things. That style is sometimes useful. It is not useful all the time. When you are deep in a known codebase and want to diagnose a failing test, inspect a diff, or make a narrow fix, the value is usually in four things: what the agent found, what it changed, how it verified the change, and what remains uncertain. Caveman is a skill/plugin built around that distinction. It makes a coding agent communicate in short, direct language its deliberately rough “caveman-speak” while aiming to leave code, commands, and errors byte-for-byte intact. The project describes this as making the agent’s mouth smaller rather than its brain smaller. Ultra Mode is an interface choice The useful way to understand Caveman is not as a substitute for reasoning. It is an interface choice for the execution phase of work. A terse agent should still inspect the repository, follow the test suite, notice ambiguity, and say when evidence is missing. It simply should not pad a simple finding with social filler. Compare these two reports: “I’ve taken a look at the component and the reason it is re-rendering is likely because a new object reference is created during each render cycle. I recommend using useMemo to memoize that object.” “New object ref each render. Inline prop = new ref = re-render. Wrap in useMemo .” The second version is not appropriate for a design document. For a developer actively debugging a React component, however, it is easier to scan and easier to act on. The underlying technical claim is the same. What Caveman actually promises The Caveman repository says it works with Claude Code, Codex, Gemini, Cursor, Windsurf, Cline, Copilot, and other agent environmen

Amazon recently announced Kiro Crew, an open-source system for running multiple Kiro coding agents across sessions, tools, and tasks. The new workspace lets developers assign asynchronous coding tasks to AI agents, allowing work such as incident investigation, ticket triage, migrations, and PR monitoring to continue without active supervision. By Renato Losio

A Japanese version of this is on Note . An increasing number of engineers and creators are running local LLMs (via Ollama, LM Studio, vLLM) and generating images with Gradio / Stable Diffusion directly on their Macs. With modern Apple Silicon unified memory, 7B and 14B parameter models run blazingly fast on-device. Many choose local AI specifically for privacy, thinking "My data never leaves my machine, so it must be secure." However, the moment developers want to test inference from their phone or a secondary laptop, they follow common online guides and set OLLAMA_HOST=0.0.0.0 or pass --host 0.0.0.0 . And right there, a critical blind spot opens up: "Wait... binding to 0.0.0.0 doesn't just expose this to my phone—it allows literally anyone on the same network to query my Mac without any authentication." As local AI tooling rapidly expands, network exposure, clipboard secrets, and model file formats remain dangerously overlooked. Here is what is actually exposed, and how we can secure our machines. 1. The 0.0.0.0 Trap: Local AI Inference Servers Are Unauthenticated by Default Whether it's Ollama ( 11434 ), LM Studio ( 1234 ), Gradio / Stable Diffusion WebUI ( 7860 ), or vLLM ( 8000 ), developers often configure OLLAMA_HOST=0.0.0.0 or pass --host 0.0.0.0 so they can test inference from a phone or a secondary laptop. The fundamental issue: almost all of these tools run without authentication by default. (Ollama has no built-in API auth at all and requires an external reverse proxy, while vLLM or Gradio require explicit --api-key or auth= configuration that is rarely set up in casual local dev environments). [Rogue Device on Shared Wi-Fi] ──── Unauthenticated HTTP Request ────> [Your Mac] Ollama (11434) - Free GPU compute hijacking - Unauthorized model downloads - Model deletion via DELETE API - Private prompt snooping If you start an inference server on 0.0.0.0 while connected to office Wi-Fi, a shared workspace, or even a home network with compromised IoT devices, an

I spent 3 months perfecting prompts. Then I deleted half of them. In late 2023 I had a directory called prompts/ with 47 carefully tuned templates. Few-shot examples, Chain-of-Thought scaffolds, a tiny ReAct loop I was very proud of. I'd A/B tested wording. I'd argued on Twitter about whether "Let's think step by step" still worked. By mid-2025 I deleted 23 of them. They weren't wrong. They just weren't the bottleneck anymore. The thing that broke my agents in production was never the prompt. It was the environment around the prompt — the tools they could call, the files they could see, the moment the loop should stop, the rollback when a tool returned garbage. The prompt was a polished doorknob on a house with no foundation. That's the story of the last three years of AI engineering, compressed: we keep renaming the layer where the real problem lives. A 40% failure rate, and it's not the model's fault Here is the number that should embarrass us. In 2026, around 40% of AI agent projects fail in production . Y Combinator's DevTool Day surveyed CTOs and CPOs in March 2026 and found a strikingly consistent post-mortem: "the difference between success and failure isn't the model." 75% of YC enterprise companies have already deployed coding agents. Most of them hit the same wall: the demo works, the prod deploy collapses. Linear declared in March 2026 that "issue tracking is dead" — meaning if your coding agent gets the issue context directly, you don't need a human ticketing layer at all. Enterprise workflows are being redesigned around agents. In that environment, shipping an agent without understanding the harness around it is like merging onto a highway without a seatbelt. You'll go fast. You'll go through the windshield on the first curve. So how did we get here? Three stages. Stage 1: Prompt Engineering (2022–2023) Scope: one input string. Prompt engineering optimized a single message. Few-shot examples. Chain-of-Thought. ReAct. The deliverable was the wording itse

For about a year, my AI code review setup looked like this: AI gets a PR, AI greps for related code, AI reads way too many files, AI says "looks fine." It mostly worked. Until the bugs that didn't show up in grep started shipping. The problem wasn't the model. It was the retrieval. Vector search and keyword grep are great at finding files that mention auth.py . They're terrible at finding files that depend on auth.py through three import hops, an event bus, and a decorator. That's where the bugs live. I rewired the retrieval layer with a code knowledge graph plugged in through MCP. Three bugs surfaced in the first week that vector search had been quietly missing. Here's what changed and the bugs themselves. Why grep + vector search missed these Vector search retrieves by semantic similarity . "Find code about authentication" finds auth.py , login.py , password_validator.py . Useful. Knowledge graphs retrieve by structural relationship . "What depends on auth.py ?" returns the call graph -- including event_handlers/login_event.py , which never mentions auth in its variable names but listens to a login event whose payload changes when auth.py changes. Both are valid. They answer different questions. The bugs that ship to production tend to live in the second question. The setup: code KG as an MCP server The Model Context Protocol (MCP), released by Anthropic in late 2024, lets you expose tools to a model in a standard way. By 2026 it's supported by Claude Code, Cursor, Windsurf, Zed, VS Code, and (as of GA in May 2025) the official MCP Registry hosts hundreds of servers. I used code-review-graph , an open-source tool that builds a property graph of your codebase and exposes it as an MCP server. The setup is a three-line ritual: pip install code-review-graph code-review-graph build ./my-project code-review-graph install # auto-detects Claude Code / Cursor / Windsurf The graph contains nodes for files, classes, functions, and tests, with edges for imports, calls, inheri

Our site, presentofai.com , publishes AI industry analysis daily with no human in the writing loop: agents ingest news and company filings into an event timeline, score them, and synthesize digests and long form articles. This post is about the part nobody plans for on day one: the verification pipeline we had to build after the writing pipeline embarrassed us. If you are shipping LLM-generated content to the public, here is the architecture that stopped the bleeding, and the specific bugs that forced each layer. Layer 1: an article-level critic After every render, a judge model checks the draft against the source events it was built from: wrong attribution, merged or split entities, date errors, dek-vs-body contradictions, load bearing claims resting on a single source, number errors. Any high severity finding triggers exactly one revision pass, grounded only in the source events. Why one pass and not a loop? Because we watched each regeneration fix the flagged error and introduce a new one, always in the hardest to verify detail: a bill's sponsors, two similar bills merged into one, a date that was actually the date reporting confirmed the event rather than the date it happened. Unbounded self-revision does not converge, it wanders. Layer 2: search-verified claim checking The critic can only see the source events. If the error is IN your source data, the critic faithfully reproduces it. So a second stage extracts every load bearing claim (who, what mechanism, when, why, number) with a neutral search query for each, runs a fresh news search per claim, reads two or three independent articles, and rules each claim supported, wrong, contested or unverified. This layer caught an invented attribution that had survived five prior review rounds: the draft credited a named former official with a specific quoted phrase, and the fresh search showed he had co-signed a group letter with different wording. The phrase belonged to someone else. One rule keeps this layer honest: t