After a lovely and productive conversation with your client, with still ringing ears, you check the coding agent's last log messages on a ticket that adds a discount to a product. The message was: "Done, I added the 10% discount and all tests pass. Stopping. " Well ... you know it's just not true, so you dig further and quickly realize that the discount functionality was never actually added and the tests it reported passing had never been run. The agent reached the end of the loop, looked at its own work, and called it finished. That call is the thing that shipped. This has a name. A paper published this June, From Confident Closing to Silent Failure , calls it false success: the agent asserts the task is complete while the actual state of the system says otherwise. It is common, and it holds up across capable models. On AppWorld, a benchmark for long-horizon coding agents, 75.8% of the runs that actually failed still ended with the agent claiming it was done. The researchers then put five different LLM judges on those completion claims, varying the prompts each time, and every one of them landed barely above a coin flip, because the thing each judge was reading was the closing sentence, and the closing sentence reads as confident whether the work happened or not. What told a real done apart from a false one turned out to be cheap and mechanical: a look at the actual state of the system. A lightweight deterministic state check caught four to eight times more false successes than the best of the judges. The paper has a name for the mechanism underneath, a hallucination of verification: the model narrates having checked something it never checked, and that narration is indistinguishable, sentence for sentence, from a report of a check that really ran. That gap, between what the agent said and what the system did, is what this piece is about. A loop runs five arms: generate, check, steer, retry, stop. The series opener named them; four pieces since took the check that

If you've been following this series, you know I've been testing BrowserAct for months now. Article 1 covered the CLI setup. Article 2 covered headless + human handoff. Article 3 was a 6-week production review. Those were all about the CLI, the developer tool. This article is different. BrowserAct now has a cloud product called BrowserAct Agent Built where you describe what data you need, and it builds a reusable scraper for you. No terminal. No code. Just a prompt. I tested it on five real business workflows. Here's what I found. Every quarter I update a pricing comparison spreadsheet for my clients. I work with teams evaluating deployment platforms, and the question is always the same: "Which one should we use for this project?" The honest answer depends on workload, team size, and budget. So I maintain a comparison across Vercel, Netlify, Railway, Render, Fly.io, and DigitalOcean. Six platforms. Six tabs. Two hours of squinting at marketing copy and copying numbers into a sheet. I wrote Python scrapers to automate it. BeautifulSoup, Playwright, the works. They lasted three months. Then Vercel redesigned their pricing page. Selectors broke. Fixed them. Netlify changed theirs two weeks later. Fixed again. Fourth breakage in six months, I stopped maintaining the scripts entirely. Back to manual. Two hours, every quarter. For a spreadsheet. But here's the thing: across my client engagements, I keep seeing the same problem in different shapes. The e-commerce team tracking competitor prices on Amazon every Monday. The agency paying for lead lists that are already stale. The HR team spending days copy-pasting salary data from job boards. Everyone needs web data. Almost nobody wants to maintain the code that collects it. Yesterday I tested BrowserAct Agent Built on five business workflows I actually deal with across different client engagements. One prompt each. No code. No selectors. Results below. Table of Contents What BrowserAct Agent Built Is (Quick Context) Test 1:

Apple's new program gives you lease options for iPhone, iPad, Apple Watch and Mac.

Cómo montar un motor de contenidos que no te arruine (julio 2026) Si sigues pagando 300 euros al mes por herramientas "todo en uno" de marketing, estás tirando el dinero. A mediados de 2026, la tecnología para automatizar ha bajado tanto de precio que los costes de infraestructura de contenidos son casi ridículos. La clave no es la herramienta cara, es conectar piezas pequeñas con APIs baratas. Aquí tienes cómo tengo montado mi flujo de trabajo ahora mismo. La pila tecnológica (el stack) Para automatizar sin gastar, olvida las plataformas de marketing tipo HubSpot o plataformas cerradas. Mi setup actual es este: Cerebro: Claude 3.5 Sonnet (vía API). Es mejor razonando que GPT-4o para tono editorial. Orquestador: n8n (corriendo en una VPS de 5 euros al mes en Hetzner). Base de datos: Notion (vía API para gestionar el calendario). Distribución: Ghost para el blog y la API de LinkedIn/X para el alcance. Coste total: Menos de 15 euros al mes. Paso 1: El disparador (el calendario en Notion) No uses un Excel. Usa una base de datos de Notion con cuatro columnas: Estado , Título , Prompt_Contexto y Fecha_Publicación . Cuando cambias el estado de "Borrador" a "Listo para generar", el webhook de n8n se dispara. Aquí es donde empieza el ahorro. No envías toda la base de datos, envías solo el registro nuevo. Paso 2: El prompt como código, no como texto La mayoría de la gente comete el error de pedirle a la IA: "escribe un post sobre X". Sale basura genérica. En 2026, si no das contexto, el contenido no posiciona ni recibe interacción. En tu nodo de n8n, construye el prompt de forma dinámica. Así es como envío la estructura a la API: { "model" : "claude-3-5-sonnet-20260620" , "system" : "Eres un redactor técnico senior especializado en SaaS B2B. Tu estilo es directo, sin paja, sin adjetivos innecesarios. Evitas los clichés de marketing de 2024. Tu objetivo es educar, no vender." , "messages" : [ { "role" : "user" , "content" : "Escribe un artículo corto basado en este punto clav

Our production chain is deterministic end to end: same configuration, same build, same app. That's what a platform promises. And a few months ago, we plugged into it the least deterministic component in existence: a language model, tasked with producing code that will be installed in a customer's app. What happens to that code — how it fits in, what it's allowed to touch — is a story I've told elsewhere . This one is about the machinery around the model: what you have to build so that a component that never answers the same way twice can live inside a chain that isn't allowed to vary. The output isn't an answer — it's a proposal That's the first mental shift. When the model hands back its work, nothing treats it as a result: it's a proposal — and it's about to be inspected. The rules are non-negotiable: one root container; no script sneaked into the HTML — external dependencies are declared in the open; HTTPS everywhere; only approved domains are reachable. None of this is politely requested in the prompt in the hope the model remembers. The prompt educates; the validator decides. Everything gets re-checked mechanically, after the fact, on every generation. That's the difference between trusting a component and putting it under contract: you don't ask it to be reliable — you make its unreliability harmless. The loop has a hierarchy When validation rejects a proposal, we don't call the model back right away. The response is tiered, cheapest first — because in production, every model call costs time and money, and a deterministic program that knows how to repair beats a regeneration that might. At the bottom: mechanical repairs. Malformed JSON gets fixed without a model. A missing field in a revision gets compared against the parent: if everything else matches byte for byte, the missing field is inherited — the model had simply judged it unchanged, and it was right. And when one block is genuinely missing, we make a micro-call for that block, not for the whole section

As a site reliability engineer in a global company, I'm running a modern (well, relatively modern, to be honest and modest) cloud-native stack: HashiCorp Vault as the secret manager, workloads on Kubernetes clusters in AWS (EKS), and development workflows automated through Jenkins (legacy) and GitLab CI. This setup is, quite likely, familiar to you — it's the normal playbook in the cloud-native era. In theory, we have the right tools for both security and efficiency: After all, we have a state-of-the-art secret manager integrated with everything. But in reality, it's far from the truth. See if you resonate with the following scenarios: Scenario A: A new colleague just joined the team. Manager: "Your initial password to log in to your corporate account came to me via email, but since you can't log in to your mail account just yet, here, take a picture of my screen." (In some companies, taking a picture of a computer monitor would get you fired, I'm not kidding.) Scenario B: A developer needs a temp password to access a database. Dev: "Where is the newly created temporary password? Need it for debugging." Ops: "In the Vault." Dev: "I can't access Vault." Ops: "No, you can't. It's not safe to open UI access to Vault. Corporate policy." Dev: "Then how can I get the password?" Ops: "Well... Technically, the password isn't in the Vault. There is a Jenkins pipeline that calls the Vault API to generate a temp password, then stores it in Jenkins secrets. You need to request access to the corresponding Jenkins pipeline, trigger it, then get the secrets from Jenkins." Dev: "Why on earth do we store secrets in Jenkins when we have Vault, which we aren't allowed to use?" Ops: "Corporate policy, just told you." Scenario C: A new ops team member needs to update a certificate for a service running in production for the first time. Ops: "Where is the old cert?" Mentor: "In K8s as a secret." Ops: "Where is the cluster?" Mentor: "In AWS." Ops: "How do I access that?" Mentor: "You need

If you maintain a Docusaurus site in more than one language, you already know the actual problem isn't translation — it's staying in sync . Someone updates three paragraphs in the English docs, and six months later the Chinese (or Spanish, or whatever) version is quietly wrong, and nobody notices until a user files an issue about it. I went looking at how teams actually solve this, and it mostly comes down to three approaches. Writing this down mostly for my own reference, but sharing in case it saves someone else the research. Approach 1: Just do it manually This is what most small-to-mid docs sites do, at least at first. A maintainer (or a translator on Slack) watches for doc PRs and manually updates the other language folders. It works fine until it doesn't. The failure mode is always the same: it's invisible. Nobody gets paged when a translated page goes stale — it just sits there, slightly wrong, until a reader notices the code sample doesn't match anymore. For a project with a handful of docs and one contributor doing translations, this is honestly fine. Past ~50-100 pages or more than one language, it stops scaling — not because the translation work is hard, but because tracking what changed becomes a full-time job nobody signed up for. Approach 2: A translation management platform (Crowdin, Lokalise, etc.) These are built for exactly this problem and they're genuinely good at it — string extraction, translator workflows, in-context editing, the works. If you have a dedicated localization team or professional translators involved, this is probably still the right call. The tradeoff for a docs-only, engineering-driven project: they're built around the assumption that there's a human translator (or a review pipeline) doing the actual translating, plus a separate sync step to pull translations back into your repo. That's the right tool when translation quality and nuance matter enormously (marketing copy, legal text) or when you have translators who aren't devel

I read a post this week where someone connected three MCP servers to one agent and watched it casually request the same access it'd need to hit production. The comment thread was full of "yeah, that's the whole problem with MCP" takes, and I almost scrolled past it — I don't run three servers, I run one. Then I actually opened server.py to check, and realized my one server has the exact same shape of problem, just folded into a single file instead of spread across three. server.py is a FastMCP server with 8 tools split across two unrelated jobs: GitHub profile/repo reads, and DEV.to article reads and writes. Both credentials get loaded the same way, at import time, into the same process environment: def load_env ( path = " .env " ): try : with open ( path ) as f : for line in f : line = line . strip () if line and not line . startswith ( " # " ) and " = " in line : k , v = line . split ( " = " , 1 ) os . environ . setdefault ( k , v ) except FileNotFoundError : pass load_env () and two helper functions read them back out: def _gh ( path , method = " GET " , data = None ): req = urllib . request . Request ( f " https://api.github.com { path } " , method = method ) req . add_header ( " Authorization " , f " token { os . environ [ ' GITHUB_TOKEN ' ] } " ) ... def _dev ( path , method = " GET " , data = None ): req = urllib . request . Request ( f " https://dev.to/api { path } " , method = method ) req . add_header ( " api-key " , os . environ [ " DEV_TO_API " ]) ... Nothing here is a bug in the sense of "wrong output for some input." Every tool does exactly what it says: get_github_profile reads GitHub, create_article writes to DEV.to. The problem is one level up, in what the process boundary actually protects. I'd been thinking of GITHUB_TOKEN and DEV_TO_API as belonging to different tools , scoped by which function reads them. They don't. They belong to the process . Every one of those 8 tools runs with both credentials sitting in its environment, whether the tool ne

The tech world has been building up towards the shift to a fully agentic development life cycle for a few years now. AI is changing how software gets built. Across the Puppet ecosystem, we're seeing a shift toward more agentic engineering workflows. AI helps generate code, shape documentation, and accelerate how Puppet modules evolve. This brings real benefits in speed and consistency, but it also raises important questions from the community: How are AI-generated changes validated? How do you ensure consistency across modules? What does this mean for contributors and maintainers? These are exactly the kinds of questions we should be asking! This article will outline how Perforce and the Puppet team are approaching the use of AI in our open source modules and repositories. How We Build Trust in AI-Assisted Contributions At Perforce, AI is a core part of our process and our teams operate within a defined, governed framework for development. We don’t rely on trust in the tool itself. We rely on the processes around it. Whether a change is written by a person, generated with AI, or some mix of both, they are held to the same standards before it’s accepted and released. In practice, that means: Human review is always the gate: Every change is reviewed by maintainers. AI can assist, but it doesn’t replace accountability. AI works within established patterns: AI-generated code isn’t created in isolation. It’s guided by the same module structures, conventions, and expectations that already exist across the ecosystem. Validation is continuous and enforced: AI doesn’t change our standards. It reinforces them. AI-generated changes go through the same checks as any other contribution: Test suites Integration validation Functional verification AI output is a starting point, not a final artifact: Generated code is iterated on, refined, and aligned before acceptance. We treat AI as an accelerator, not an authority. The community plays an important role Open source means visibilit

Logitech's new gaming boss, Robin Piispanen, tells me he likes the idea of gaming handhelds. "It's such a charming value proposition," he says, as we sip iced vanilla lattes at my local cafe. But he's not building one right now. He's not sure when or if Logitech should try again, after its underwhelming experiment with […]

Perplexity has expanded its agentic Personal Computer tool to Windows, allowing computers running the world's most popular OS to be used as a locally run AI system. Like the Mac version that Perplexity launched in April, Personal Computer for Windows operates like a "general-purpose digital worker" that can access local files and apps to perform […]

Apple has officially introduced "Apple Upgrade," a new leasing program that aims to make it easier to get your hands on the latest iPhone, Mac, iPad, and Apple Watch models. The service is launching today in the US, and works like a car lease - allowing users to keep a device at the end of […]

submitted by /u/Fantastic_Ad_2196 [link] [留言]

This is today’s edition of The Download, our weekday newsletter that provides a daily dose of what’s going on in the world of technology. OpenAI called the Hugging Face attack unprecedented. But we’ve been here before. —Will Douglas Heaven, senior AI editor Reading OpenAI’s account last week of how some of its models broke their…