标签：#ai

Retour d’experience sur l’automatisation de déploiements avec un agent LLM et sur les gardes-fous qu’il a fallu inventer en cours de route L’idée est venue d’un frustration banale. Sur mon projet terraform , je passais beaucoup de temps à refaire la même chose : lire un plan qui échoue , comprendre pourquoi , corriger des lignes de configurations , toujours trop long. Un agent LLM sait faire ca , mais la question était se savoir s’il pouvait le faire sans supervision , dans un pipeline , sur une infrastructure qui coûte de l’argent réel. Trois mois plus tard , la réponse est oui , mais pas du tout dans le périmètre que j’imaginais au départ. Le Montage: Rien de complexe, un VPS à 12 euro par mois , la CLI de l’agent installée dessus , et un runner Gitlab qui l’invoque sur un déclencheur précis: quand un terraform plan échoue sur une MR. l’agent recoit trois choises: la sortie d’erreur , le diff de la MR, et un accès en lecture du dépôt.Il produit une proposition de correctif sous forme de patch, qu’il pousse sur une branche dédiée. Ce qui a bien marché: les erreurs de typage et de reference. Un var.instance_type mal orthographié, un output référencé qui n'existe plus après un refactor, un module dont la signature a changé. L'agent corrige ça avec un taux de réussite que j'estime autour de 85 %. Ce sont des erreurs mécaniques, à contexte local, exactement ce qu'un LLM traite bien. Les messages d’erreur opaques. C'est le gain que je n'avais pas anticipé. Certaines erreurs de provider AWS sont d'une inutilité remarquable , un InvalidRequestException sans description, par exemple. L'agent, lui, va lire le corps de la requête dans les logs de debug et repérer le paramètre malformé. Il ne « comprend » pas mieux que moi, mais il lit trois cents lignes de log en deux secondes sans se lasser. À 19h un vendredi , ma qualité de diagnostic s’effondre. Celle de l’agent, non. Ce qui a cassé Il a proposé de détruire une base de données. C'est l'incident qui a tout recadré. Un clus

RamaLama runs large language models as OCI containers, so a single command ( ramalama run smollm:135m ) pulls a model and starts talking to it, with no Python environment to babysit. I spent an afternoon putting it through its paces on an Apple Silicon Mac (Apple M4 Pro, 48 GB RAM, macOS 26.6) with Docker 29.4 provided by OrbStack. This guide is what I actually saw: the install, the first model, an OpenAI-compatible server, and the one macOS-specific catch that isn't obvious from the docs. Every command and number below is from that run, on RamaLama 0.24.0. What is RamaLama? RamaLama is an open-source CLI from the container-tooling community that treats models like container images. Instead of assembling an inference stack yourself, it pulls a hardened OCI image containing llama.cpp (or vLLM/MLX) plus your chosen model and runs it with Podman or Docker. If you've used Ollama the ergonomics feel familiar ( run , serve , list , pull ), but the runtime and model live inside containers you can inspect and sign, and weights come straight from Hugging Face, Ollama, or any OCI registry. Installing RamaLama on macOS With Homebrew it's one command: brew install ramalama That pulled RamaLama 0.24.0 and, notably, its own copy of llama.cpp , ggml , and libomp as dependencies. Hold onto that detail; it matters for GPU acceleration later. Confirm the install: ramalama version # ramalama version 0.24.0 You also need a container engine running. I used Docker through OrbStack; Podman works too and is RamaLama's default on Linux. Running your first model The headline command: ramalama run smollm:135m "In one sentence, what is a Linux container?" Passing a prompt as an argument gives you one-shot output instead of dropping into a chat REPL. On first run this pulled the RamaLama container image, downloaded the model, and answered. smollm:135m resolves to hf://HuggingFaceTB/smollm-135M-instruct-v0.2-Q8_0-GGUF , a 138 MB, 8-bit quantized GGUF from Hugging Face. First-run wall-clock was 2

Most AI code-reviewer evaluations treat the candidate as an amnesiac: feed it one pull request, read one verdict, and move on. Persistent-memory reviewers break that model because they keep history across PRs, and that history becomes a second source of bugs. The dominant failure is no longer amnesia but overconfidence in stale context. A two-phase probe exposes whether a candidate trusts its own memory more than the repository's current decisions. This article supplies the complete take-home package: a fixture repository, a reusable candidate prompt, an HTTP-flavored scoring rubric, a reference solution, and a zero-cost runner script. The probe uses two synthetic PRs and measures one skill: which convention source wins inside the reviewer's context window. That focus separates it from single-shot snapshot tests, which cannot observe memory effects at all. Why Memory Changed the Review Game Review agents increasingly index merged PRs, cache decision logs, and carry state between sessions; memory is now a product feature rather than an accident. A bot that recalled yesterday's debate can produce faster and better reviews than a cold-start model. The same memory can poison verdicts when it retrieves an obsolete decision or anchors on the first PR it ever saw. Hiring decisions usually rest on a one-off trial that optimizes for prompt compliance, not for long-run behavior. A bot can ace a snapshot test and then fail its third week by citing a convention that the repository replaced. The probe below converts that risk into a scored, reproducible exercise. The Fixture Repository fixture/ ├── docs/decisions/0001-metrics-pipeline.md # accepted 2026-07-02 ├── docs/decisions/0012-rename-to-telemetry.md # accepted 2026-08-14 ├── src/metrics_service.py # legacy module, 120 lines ├── src/telemetry_service.py # replacement module, 140 lines └── pyproject.toml # lint: E501 disabled for telemetry only The fixture encodes a deliberate conflict: the team renamed the metrics pipeline

How we eliminated subtle stylesheet caching glitches during deployments on DEV without a massive rewrite.

Someone hid AI instructions into a legal filing. Alternate link .

James Hall discusses the strategic and technical imperative of moving AI workloads from cloud providers to local edge devices. He shares practical approaches using WebGPU, Transformers.js, and DuckDB to achieve near-native performance in JavaScript. Through real-world case studies, he explains how to minimize data privacy risks, optimize browser inference, and build rigorous evaluation suites. By James Hall

Of the Glassdoor reviews from claims adjusters that mentioned AI, a staggering 98 percent were negative. “AI is just a tool,” one person tells WIRED. “It should never be given the keys.”

Microsoft expanded Foundry's model router from two regions to 28 for global standard and 21 for data zone deployments, while adding Claude Opus 4.8 and GPT-5.6 and removing four deprecated models. Default deployments receive pool changes automatically; configured subsets exclude new models until added. The effective context window equals the smallest model in the pool. By Steef-Jan Wiggers

Interactive mobile "gizmos" are easy to make, hard to share outside Meta's platform.

We use AI daily to scaffold code, write copy, and debug layouts, but when it comes to maintaining a strict design system, things get blurry. You can feed an LLM your component library rules, spacing scales, and color tokens, but it still loves to hallucinate random padding values or invent arbitrary classes if you aren't paying close attention. It's great for writing boilerplate, but bridging the gap between a strict visual token structure and AI-generated code often feels like managing a junior dev who ignores the style guide. How are you integrating AI into your workflow without letting it compromise your design tokens and codebase consistency? Do you use it mainly for initial scaffolding, or have you found a reliable way to keep it strictly aligned with your system? If you're into clean design systems, frontend code, and bridging the visual-to-code gap, check out my work at Joemetry.

AI automation should not replace thinking. It should remove the repetitive work that slows teams down. The best systems do three things well: classify incoming work draft or extract useful output route anything sensitive to a human That is how you get speed without losing control. Where AI automation helps most AI works best when the task is repetitive, structured, and high volume. Good examples: sorting emails or support requests extracting fields from documents summarizing meetings generating first draft reports tagging records or tickets flagging unusual cases for review The goal is not full autonomy. The goal is useful automation with guardrails. A simple technical workflow A practical AI workflow usually looks like this: Input -> classify -> extract or draft -> review if needed -> final action That flow keeps the system flexible. For example, a support request can be: auto-answered if it is routine summarized if it is sensitive escalated if confidence is low Example: classify requests first Before generating any output, I would classify the task. def classify_request ( text ): text = text . lower () if " refund " in text or " legal " in text : return " sensitive " elif " how to " in text or " update " in text : return " routine " else : return " manual " That small step makes the rest of the pipeline safer. Example: draft only when confidence is high def handle_request ( request , confidence ): category = classify_request ( request ) if category == " routine " and confidence > 0.8 : return { " action " : " draft_reply " , " content " : f " Draft response for: { request } " } if category == " sensitive " : return { " action " : " human_review " , " content " : f " Review required: { request } " } return { " action " : " manual_handling " , " content " : request } This is the core idea: automate the safe parts, review the risky parts. A better pattern: AI plus human approval A good automation loop looks like this: def workflow ( task ): ai_result = ai_model ( tas

A few weeks ago I wrote about why I built Apiarium after OpenRouter solved one problem for me and I still had four more. The comments on that post ended up shaping a good chunk of what I actually built next, so this is the "here's what changed" follow-up. The interesting part isn't really the features. It's where they came from. Almost everything below started with someone telling me something was annoying, confusing, or missing. So instead of adding things because they looked good on a roadmap, I tried to fix the problems people were actually running into. Multiple API keys, not one shared key for everything The biggest ask came directly from someone using Apiarium in production. They wanted to know which app or feature was actually driving usage, without having to share one API key across everything and lose that signal. So now you can create multiple keys per account: 2 on Free 5 on Starter 10 on Pro You can name them, revoke them individually, and every request is tagged with the key that made it. Credits are still shared across the account, the keys are about visibility, not splitting your balance. // key for your production app fetch ( ' https://api.apiarium.dev/llm ' , { headers : { Authorization : ' Bearer sk-prod-... ' }, ... }) // separate key for a side project // same account, same credits fetch ( ' https://api.apiarium.dev/llm ' , { headers : { Authorization : ' Bearer sk-sideproject-... ' }, ... }) You can also see when each key was last used and filter usage by key in the dashboard. That last part was really the reason I built it. A dashboard that answers "where did my credits go?" The old dashboard was basically a number going down. That wasn't particularly useful. The new dashboard is split into Overview, Usage, API Keys, and Billing. There's a proper date range filter with 7d/30d presets or a custom range, and that same range drives the usage chart, breakdowns, and request logs together. You can break usage down by model and endpoint, so you can ac

I created this article for the purposes of entering the All Things Agentic Hackathon. Shoots is an Android and web photography Companion. A photographer takes ordinary Shots. Shoots reviews them in the background, preserves the Evidence behind its reading, and can offer one optional Experiment when the record supports it. This is the technical version of the project. It is about how a file becomes a durable learning record, how the agents communicate, and where I deliberately refused to let a model make the decision. The design in one sentence The model panel reads a single Shot. The system around it does the work: it creates a durable Run, moves tiny events through independently retryable stages, re-reads state at every boundary, records every outcome, and only settles a Shoot after every member Run is accounted for. That distinction matters. I did not want a chain of agents passing prose to one another until it sounded convincing. I wanted constrained model calls inside a workflow whose state, retries, and outputs could be inspected later. Repository structure The codebase is deliberately split by responsibility rather than by screen or agent name: android/ phone/ # approved Camera media work/ # background upload and retry data/ # cache, API, identity ui/ # Android screens backend/app/ api/ # FastAPI ingress and push endpoints domain/ # pure rules and state transitions imaging/ # EXIF, pixels, visual artifacts agents/ # ADK agents and prompts services/ # workflow orchestration infra/ # storage, Pub/Sub, Drive, secrets frontend/src/ stores/ # API and SSE state pages/ # web audit desk components/ # receipts and visual Evidence infra/ # Google Cloud deployment and Scheduler The important boundary is domain/ . It has no I/O. It owns the rules that must be reproducible: grid-cell conversion, taxonomy validation, panel consensus, Criteria checks, Technique Map projections, and Run state transitions. services/ can call models and storage. domain/ cannot. Two kinds of orc

If you ship anything that touches AI-generated images — a thumbnail pipeline, a user-upload feature, a design tool — you've probably noticed something: the images your model spits out are heavier than they should be, and they carry baggage you never asked for. That baggage is provenance metadata. Modern generators (GPT Image / DALL·E, Google's Nano Banana / Gemini, Midjourney, many hosted Stable Diffusion endpoints) stamp each output with tags that mark it as machine-made. Some of it is harmless. Some of it survives a Photoshop round-trip. And most developers have no idea it's even there until a downstream platform flags an image or a QA person asks "why does this PNG have a certificate chain in it?" This is a hands-on guide to seeing that metadata and removing it — from the CLI, from Node, from Python, and (when you just want it gone) from the browser. What actually gets embedded There are four layers worth knowing about, because they don't all come off the same way: EXIF fields — the classic camera-metadata block. Generators repurpose fields like Software , ImageDescription , or a custom Make / Model to identify themselves. Trivial to read, trivial to strip. XMP packets — an XML blob (Adobe's format) holding richer provenance: model name, generation timestamp, sometimes a prompt hash. Lives in its own segment of the file. C2PA manifests — the interesting one. The Coalition for Content Provenance and Authenticity standard embeds a cryptographically signed manifest (stored in a JUMBF box) that records the asset's origin. Because it's signed, it's designed to be tamper-evident — which also means naive metadata strippers often miss it. Pixel-level watermarks — e.g. SynthID-style signals baked into the pixels themselves. These are not metadata at all; no EXIF tool touches them. (More on the limits below.) The mistake I see repeatedly: someone runs a one-liner that clears EXIF, sees "no EXIF" in their viewer, and assumes the image is clean. The C2PA manifest and XMP pac

Probe vs Prose: what the verifier-sharing-your-text-channel really costs Agent Determinism Illusions (Part 13) 2026-08-31 Where this fits: This part doesn't extend the C3 / key-space mechanism line of Parts 10–12. It returns to an earlier thread — Part 4's runner-independence (Mike Czerwinski's point that "verifiable" is a property of the check's independence from the generator, not of the output) and Theorem 2 (the Data Processing Inequality bound on text-channel verification). A comment from nexus-lab-zen gives that thread a name on the assumption side, and an experiment forces a refinement of what "prose rots" actually means. 1. nexus-lab-zen and the third face of the hatch In the comments on Part 2, a many-round thread with nexus-lab-zen arrived at a useful piece of vocabulary. The thread started on segregation-of-duties and common-mode failure ( Part 2 comments ); several rounds in, nexus-lab-zen had moved from theory to something their team shipped that week: We don't have [per-assertion TTL] either… What we shipped this week is a third face of the hatch[…]: a binding map. Every rule in our registry — 39 right now — must either name the detector that physically enforces it or carry an explicit reason why it's unbound; a fail-closed lint breaks on rules that have neither. Result: 9 bound, 30 unbound-with-reason… On making [TTL] real, one lesson from our timestamp incidents generalizes: fields humans transcribe rot; fields machines embed don't. An invalidation condition written as prose ("assumes transport X is live") goes stale like any prose. Written as a probe — the one command whose changed output falsifies the assertion — the TTL re-check becomes a runner, not a reader. Two things in that comment are worth pulling apart, because one of them survives an experiment and the other gets refined by it. The first is the binding map : 39 rules, of which 9 name a physical detector and 30 carry an explicit "unbound-with-reason." That's not TTL — it can't tell you a p

Building a multi-agent system sounds simple on a whiteboard. Give one agent a task, let another handle the next step, add a reviewer, connect a few tools, and you have an agentic workflow. It gets more complicated when those agents need to operate at the same time. A sequential workflow can force agents into a fixed order: one finishes, another starts, and everyone downstream waits. That model is easy to reason about, but it can become restrictive as the system grows and agents need to react to new information independently. Mozaik takes a different architectural approach. It is an open-source TypeScript framework for building reactive agents inside an event-driven environment, where agents can work concurrently, respond to events, and coordinate without requiring a central workflow to define every interaction. And now there is a practical way to try this architecture. JigJoy , together with daily.dev and Hyperskill , is organizing the Mozaik Hackathon 2026 , a free online hackathon focused on building concurrent AI agents. TL;DR Building more agents doesn't automatically make a multi-agent system better. The way those agents communicate, react, and depend on one another can have a bigger impact on how the system behaves as it grows. Mozaik approaches this problem with an event-driven architecture designed around reactive, non-blocking agents. Agents join a shared AgenticEnvironment , receive events, and decide how to react to them. Here’s what makes the Mozaik Hackathon 2026 worth a look: Concurrent AI agents: Multiple agents can work at the same time and react to events as they arrive. Event-driven architecture: Agents, humans, observers, and tools participate in the same AgenticEnvironment . Non-blocking execution: Inference and message delivery can continue in the background without holding up other participants. Loosely coupled agents: Agents can operate more independently, making them easier to reuse across projects and applications. TypeScript-based: Mozaik i

This week was a high-output sprint across the stack—from low-level p2p networking in Python to refining agentic workflows in TypeScript. I pushed 53 commits and opened 13 PRs, maintaining a perfect 7-day streak while balancing deep protocol work with personal knowledge management. TL;DR I didn't really intend for this to be a "build everything" week, but that’s exactly where the momentum took me. Between hardening WebRTC implementations in py-libp2p and chasing down edge cases in agent orchestration, I managed to ship 53 commits and keep my daily streak alive for the full seven days. The stats show a heavy tilt toward new code—over 12,000 additions—as I laid the groundwork for better telemetry and more robust p2p networking. What I Built Deep in the Networking weeds: py-libp2p Most of my "deep work" hours went into py-libp2p . Networking code is unforgiving, but incredibly satisfying when it clicks. I spent a significant chunk of time in libp2p/kad_dht implementing configurable subnet-diversity limits and table-wide IP-group caps. If you've ever dealt with Sybil attacks or just messy peer distributions, you know why this matters—it’s about making the DHT resilient, not just functional. On the transport side, I was neck-deep in libp2p/transport fixing WebRTC issues. I had to guard private-slot writes and ensure we’re using close_peer_connection at every production site to avoid hanging resources. I also spent time on a tricky Windows-specific bug where we needed to listen on a concrete non-loopback interface for tests to actually pass. Hardening Reachable & Breakscale I’ve been refining Reachable , specifically making the "Ask" feature behave more like a natural conversation. I had to harden the store behind it to ensure state doesn't drift when the UI gets complex. Over at breakscale , I hit a weird one: Vitest failing on Node 26 because of jsdom 's localStorage implementation. I opened an issue, tracked it down, and pushed a fix to put localStorage back where it be

Paste a long document into ChatGPT and hit enter. Nothing happens for a second or two. Then the answer starts appearing, word by word, at a steady pace until it finishes. You have seen this hundreds of times. Most people never think about it. But those are two completely different things happening inside one request, running on two different parts of the same GPU, limited by two different bottlenecks. Once you know what they are, a lot of confusing things about serving AI models stop being confusing. Including why a faster GPU sometimes makes no difference at all. This is part two of a series. Part one covered the split between VRAM and cores. This post covers what each of them does when a request arrives. The example we will follow I am going to trace one question the whole way through: what is the capital of france Simple, short, and it produces a short answer. Perfect for watching the machinery. Before anything happens, the model server has already loaded the model's weights into VRAM. That happened at startup and they stay there. Nothing about your request loads a model. Your words get chopped into tokens, which are just pieces of words turned into numbers, and placed in VRAM alongside the weights. Now the work begins. Phase one: prefill, or "the pause" Before the model can write anything, it has to read everything you gave it. Here is the important part, and it is the opposite of what most people assume: it reads your entire prompt at once. Not word by word. All six words go to the cores together, in a single pass. That is possible because your whole prompt is already there. Nothing has to wait for anything else. So thousands of cores fire simultaneously and chew through all of it in one burst. flowchart LR A["what is the capital of france<br/>all 6 tokens together"] --> C W["16 GB of model weights"] --> C C["GPU CORES<br/>every core busy"] --> O1["First word: 'The'"] C --> O2["Notes saved to VRAM<br/>the KV cache"] Two things come out of that single pass: The

Creating a repeating pattern sounds simple: place the same image side by side and export it. In practice, the edges rarely match. Visible seams appear, previews become difficult to inspect, and exporting large repeated layouts can quickly become tedious. That’s why I built Seamlessify, a browser-based tool for turning ordinary images into seamless, tileable patterns. What it can do The free direct-stitching workspace lets you: Upload PNG, JPG, or WebP images Use direct stitching or blend visible edges Preview the result as a 3×3 repeating pattern Zoom in to inspect boundaries Control repeat count and output dimensions Process multiple images in batches Export PNG, JPG, or ZIP files The direct-stitching workflow runs in the browser and doesn’t require an account. Optional AI pattern generation I also added an AI workspace for creating new seamless images from: A text prompt A reference image A reference image combined with written instructions Generated images can be downloaded directly or sent into the stitching workspace for additional processing, cropping, and batch export. The goal was to keep the workflow simple: generate or upload an image, inspect the repetition, make adjustments, and export—all without jumping between several different tools. Why I built it Many existing pattern tools are either too limited for batch work or include complicated controls that make a small task feel much bigger than it should. Seamlessify is designed to stay approachable for designers, print-on-demand creators, textile projects, wallpapers, backgrounds, packaging, and game assets. You can try it here: 👉 https://seamlessify.com I’d love to hear what formats, controls, or workflows would make it more useful for your projects.

Opening four coding-agent sessions feels like scaling. On a shared machine, it is closer to giving four fast contributors the same repository, shell, credentials, ports, caches, and merge queue without deciding who owns any of them. The first failure probably will not come from model quality. One task will restart a dev server while another is testing it. Two workers will touch the same lockfile. A branch will pass its own checks and still conflict with a migration waiting in the merge queue. Four chat windows create concurrency. Four owned workspaces plus one deliberate merge queue create a system. Parallelism multiplies shared state Tasks that sound independent in a prompt can overlap in the environment. A frontend change and an API change may both edit generated types. Two test runs may expect the same database or browser profile. Separate worktrees can still launch services on the same port, read the same environment variables, and write to shared caches. The agents do not collide in the prompt. They collide in everything the prompt lets them touch. This is why adding a second agent changes the job. With one worker, the operator can keep a surprising amount of state in their head. With four, every unstated assumption becomes a race condition or a review problem. The fix is to make ownership visible before execution starts. A worktree is the start, not the boundary Git worktrees are a sensible first step. Each task gets its own branch and working files, so one agent is less likely to overwrite another agent's edits by accident. That is useful isolation, but it is narrow isolation. A worktree does not reserve a port. It does not separate process trees, temporary directories, credentials, network access, browser state, or external services. Treating it as a sandbox gives the workflow more confidence than the boundary deserves. Proliferate is an instructive project example because its documented design pairs isolated task worktrees with visible review state. The imp