标签：#ai

One executor, one pass, one commit - and the work can be dropped at any boundary. 👋 I'm Anton - a software engineer working mostly in PHP/Symfony and Go, currently carving a live PHP monolith into Go services. Earlier parts of this series were about what an executor must know, how small a unit of work has to get, and how to write a task with nothing left to interpret. This part is about the thing I only learned by having to stop in the middle: the unit at which work becomes droppable . Notes: github.com/brilliant-almazov . Maybe you already do this better, maybe you organise it differently - either way I'd rather hear how than assume mine is the shape. As always: these are my habits on one codebase, not advice for yours. The evening I had to stop mid-stage A stage of 13 iterations . The first wave had closed, the second wave was running, and I had to put the work down right then - not "wind it up", not "finish the current thing", stop. There was exactly one question worth asking, and it wasn't "how far did I get". It was: What is sitting uncommitted, and what would I have to reconstruct from memory? The second half of that question is the trap, because of how the executor works. It carries nothing between tasks. No dialogue history, no memory of the previous iteration, no accumulated sense of "where we were". Every task arrives complete or it doesn't arrive at all. So "I'll pick it up tomorrow and it'll remember roughly where we were" is not available to me at any price. Tomorrow's executor starts from zero, from the text I wrote. Which means the only thing that survives an interruption is what's written down and committed . Everything else is in my head, and my head is the least reliable component in the pipeline. I want to be precise about the framing, because this is the part I got wrong for a while. Being interrupted is not an emergency to be handled. It is the normal case. A day ends, a production incident lands, a call runs long, priorities move. If the way I

UOB polled business owners across the region and found something most vendors will not put on a slide: 65% of businesses have adopted AI in some form, but only 15% have reached what the study calls advanced capability. Read that again. Four out of five companies using AI are stuck somewhere between "we tried it" and "it changed how we work." The barriers the respondents named are where it gets interesting. Data and system readiness: 47%. Funding: 47%. Talent: 39%. Funding and talent are the answers people give. Data readiness is the answer that is true. The pilot always works. That is the problem. Here is how it goes in real companies. Someone uploads three months of sales data to a chatbot and asks it to find the slow-moving stock. It comes back with a clean answer in eleven seconds. Everyone in the room is impressed. The pilot is a success. Then you try to run it every week, across every product line, and it falls apart. Not because the AI got worse. Because the three months of data in the pilot were cleaned by hand by the one person who understood the mess. Nobody has time to do that every week for the whole catalogue. The pilot worked on a sample. Production needs a system. This is why the same study shows a 28-point gap in digitalisation success rates between large and small enterprises, and why only 69% of small enterprises here are digitalised against 93% of large ones. It is not that big companies have better AI. They have somewhere for the data to live. What "data readiness" actually means Strip out the consultant language and it means four unglamorous things. One record per thing. One customer, one code. Not "ABC Trading", "ABC Trading Pte Ltd" and "ABC" as three separate lines that no tool can add together. Numbers that update themselves. If your stock figure is a spreadsheet someone types on Fridays , every answer built on it is Friday’s answer. History that survives people leaving. If the reason a customer gets 12% is in someone’s head, no model will ev

An observability-first approach for building an AI agent, and what it bought me. A couple of weeks ago I started implementing Kept, a self-hostable post-purchase support agent for e-commerce, with reliability as its core offering. Besides the product itself, my objective in building it is to delve into the depths of agentic system design, and see what it actually means to build an agent with "reliability at its core". Observability first I started from a theory my experience validated again and again throughout the years: observability is the bedrock of reliability. Proper logs and metrics beat an ideal architecture, industry-leading frameworks or best coding patterns. That was the case well before the agentic era, and I've always paid particular attention to this layer. But with the advent of non-deterministic LLMs sitting at the core of products, I decided to take that to the next level: designing and implementing the full tracing layer before writing a single line of code for the main agent loop/product. Turned out to be an insightful experience. Up next I'll walk through how I designed and implemented the tracing layer, then present 3 benefits and 2 drawbacks that I consider worth highlighting from the observability-first approach, and end with some thoughts on how to apply the approach if you don't have the luxury of starting with a fresh codebase. Tracing layer design and implementation I started with an AI-assisted research phase. Here's a list of resources I found particularly useful: Anthropic, "Building Effective Agents" OTel blog, "Inside the LLM Call: GenAI Observability with OpenTelemetry" John Hodge, "OpenTelemetry GenAI semantic conventions" OTel GenAI semantic conventions, the dedicated repo Langfuse data model 0. The guiding design decision The research produced the first important insight. My original idea was to have Langfuse as the source of truth that saves all spans and traces and serves them wherever they're needed. But then I realized I'd hav

Introduction When you build a shipment control tower with ToolJet MCP, freight operations...

The eyebrow-raising proposal, delivered during the president’s speech at the midterm convention, would cost $1.2 trillion and would need congressional approval.

If you've ever built an application that integrates with multiple LLM providers (Anthropic, Google, OpenAI, DeepSeek), you already know the pain: Each provider has its own distinct Python SDK. Streaming responses using Server-Sent Events (SSE) requires divergent parser logic. Thinking / Reasoning blocks are formatted completely differently. I recently extracted the core streaming router from my platform into an open-source FastAPI template. Here is how it works. Objective A single asynchronous endpoint: POST /v1/chat/stream It accepts a unified request payload and returns a standardized SSE stream emitting four clean events: event: thinking — Internal model reasoning tokens (streamed in real-time). event: content — User-facing response text. event: tool_call — Function calling requests. event: done — Stream completion ( [DONE] ). Architecture Instead of pulling heavy wrapper frameworks, use direct asynchronous HTTP via httpx.AsyncClient and the official Google GenAI SDK: fastapi-multi-llm-starter/ ├── app/ │ ├── config.py # Pydantic Settings loading environment variables │ ├── main.py # FastAPI app with CORS, health check & test playground │ ├── models.json # Dynamic model catalog (Claude, Gemini, GPT) │ ├── router.py # Unified multi-provider async stream dispatcher │ └── schemas.py # Strict Pydantic v2 validation models ├── tests/ # Automated unit tests (pytest) ├── requirements.txt └── README.md Dynamic Model Catalog I disliked the idea of hardcoded models, so I decoupled them into a models.json file: { "models" : [ { "id" : "claude-sonnet-5" , "name" : "Claude Sonnet 5" , "provider" : "Anthropic" , "thinking" : true }, { "id" : "gemini-3.8-flash" , "name" : "Gemini 3.8 Flash" , "provider" : "Google" , "thinking" : true }, { "id" : "gpt-5.6-terra" , "name" : "GPT 5.6 Terra" , "provider" : "OpenAI" , "thinking" : true } ] } Now, if you want to add another model, you just edit the JSON. The backend and the embedded UI dynamically populate available models via GET /v

Disclosure: Software Sausage is our product. Agency Agents did not sponsor, review, or endorse this article. AI tools helped draft and edit it; the evidence boundary is stated below. You probably do not need 264 AI agents. You need bounded roles and a gate The Agency Agents repository is difficult to ignore: 264 specialized agent definitions, broad coding-harness support, and—when I reviewed it on September 9, 2026—roughly 151,000 GitHub stars. The tempting conclusion is that a larger virtual team produces better work. The repository does not establish that. What it does provide is a useful, MIT-licensed role library and a competent installer. The value comes from selecting a few narrow roles and making their outputs pass real checks. This is a source review at commit 6d29a9b , not a benchmark. I inspected the role files, installer, converter, contribution rules, workflow example, and current GitHub checks. I did not evaluate every integration or the desktop app. What it gets right Agent definitions are not one-line personas. They name deliverables, workflows, constraints, and success metrics. The project converts them for Claude Code, Codex, Cursor, Gemini CLI, OpenCode, Qwen Code, Aider, and other harnesses. More importantly, the installer lets you select one role or division, show a dry run, and target an explicit path. Agency Agents itself warns that OpenCode currently registers only about 119 agents and recommends installing a subset. The project's contribution guide contains the best design rule: a new agent needs a narrow specialization, distinct behavior, concrete deliverables, measurable success, and real testing. Near-duplicate re-skins are rejected. That rule should apply to the workflow too. If two roles produce the same artifact, if nobody consumes an output, or if success cannot be checked, remove the role. What it does not prove The README's “never sleep” and “always deliver” language is marketing. Prompts still fail, time out, overrun context, and ag

Quick Answer AI Orchestration for Enterprise .NET Applications: AI orchestration adds a disciplined layer to .NET apps, coordinating agents, caching, state, and compliance to reduce latency, cost, and hallucinations. AI Orchestration for Enterprise .NET Applications – A Production‑Ready Playbook Scaling Pitfalls of Single-Request AI Calls In many .NET shops the first step to “add AI” is to fire a single HttpClient request from a Razor page. That works for a handful of users, but as traffic grows the pattern quickly turns into a latency, cost, and reliability nightmare . The root cause isn’t the LLM – it’s the absence of a disciplined orchestration layer that can coordinate agents, cache prompts, persist state, and enforce compliance. When you look at the stack, the pain points are clear: Unpredictable token usage and cost spikes Inconsistent latency across users and regions Hallucinated results that break downstream business logic Duplicated retry and state‑management code in every microservice Hard‑coded secrets and opaque audit trails Real‑World Example Consider the U.S. retail platform that added a product‑price‑alert feature. The initial prototype wired a Razor page directly to GPT‑4. Within a few days the service hit 10 k concurrent users, token costs blew past the budget, and the model started hallucinating prices. The team eventually built a lightweight orchestration layer that: Cached the last known price in Redis to avoid duplicate LLM calls. Persisted price history in Cosmos DB for audit and compliance. Enforced a maxTokensPerConversation policy to keep costs predictable. Used Azure Service Bus for long‑running workflows and SignalR for real‑time alerts. Result: latency dropped from 1.2 s to < 150 ms per SKU, token usage fell 40 %, and the feature survived a 50× traffic spike during a holiday sale. Trade‑offs Every architectural decision in AI orchestration comes with a cost. Below are the key trade‑offs you’ll face and how to evaluate them: Decision Pros

🚀 Why Traditional GitHub Trending Falls Short for AI Engineers If you build with AI coding agents (Claude Code, Cursor, Codex, Antigravity), you’ve probably noticed a major blind spot in developer tooling: discovery . GitHub's native trending feed is useful, but: It ignores velocity dynamics: A repo with 50 stars gaining 40/day is moving faster than a 100k repo gaining 5, but gets buried. No taxonomy for the Agent Ecosystem: There’s no native way to filter specifically for Model Context Protocol (MCP) servers , Agent Skills , or Local LLM frameworks . Coding agents can't read it mid-task: You have to manually browse in a browser, search, clone, and configure. To solve this, I built and just shipped GitTrends AI v5.0 — an open-source Swiss Editorial developer registry, real-time star velocity tracker, and automated intelligence engine. 🌐 Live Web App: https://jastfan.github.io/github-trending/ 💻 Source Code: https://github.com/jastfan/github-trending 📦 NPM Package: gittrends-mcp ⚡ 1-Click Coding Agent Discovery (Native MCP Integration) You don't even have to leave your terminal or IDE to find breakout skills and repositories. GitTrends AI ships with a native Model Context Protocol (MCP) server. For Claude Code: claude mcp add gittrends -- npx -y gittrends-mcp For Cursor ( .cursor/mcp.json ) & Antigravity: { "mcpServers" : { "gittrends" : { "command" : "npx" , "args" : [ "-y" , "gittrends-mcp" ] } } } Now, your agent can query live GitHub breakouts, star velocities, and curated MCP tools automatically while coding! 🌟 What’s New in GitTrends AI v5.0 1. 🏆 4 Numbered Editorial Leaderboards Rather than a cluttered raw list, the new dashboard categorizes the ecosystem into high-signal leaderboards: Agent Skills: Battle-tested plugins and tool recipes for coding agents. MCP Servers: Verified stdio and SSE server implementations. Ecosystem Marketplaces: Curated hubs and catalogs. Star Velocity Radar: Emerging breakout repos ranked by net 24-hour star surge (+stars/day). 2. 🎨

When Cleanup Resets the Retry Budget A retry limiter can record an attempt correctly and still lose control before the next call. An Orca recovery-module experiment exposed the reason: display cleanup erased a terminal's recovery history while that terminal remained eligible for another remount. The useful review target is the cleanup predicate. Adapted from the complete English research article . Two indexes disagree about one object Orca is a desktop tool for organizing terminals and Agent work. PR #19745 describes a Windows crash in which eight tabs reportedly remounted 8,878 times in roughly 122.4 seconds. We did not obtain the original crash bundle; those numbers are the author's incident report, not our measurements. The public code exposes a mechanism worth testing. Terminal rows live in one index, while unified UI tabs live in another. They usually correspond but can diverge. Remounting consults the terminal-row index. The old budget-release path consulted the unified UI index instead. The same tab could consequently receive two incompatible answers: it existed for the function performing a remount, but appeared absent to the cleanup function deciding whether to erase its recovery history. Each lookup returned a definite answer. Their combination allowed recovery to discard the evidence of its own activity. Test the causal path without claiming a desktop reproduction We pinned the base and proposed head revisions and loaded the complete recovery and lookup modules. The original budget calculation, instance disposal, remount and generation-update logic remained intact. We supplied fixtures for store plumbing, time, timers, PTY and logging. We did not start Electron or reproduce graphics-memory exhaustion. Each cycle registered an instance, requested recovery and unregistered it. We then made the UI index miss a tab whose terminal row remained present. Two request schedules tested different constraints: 10 milliseconds between calls for the cooldown, and 16 se

A strange thing happened when fal made H3 Max faster than realtime. The obvious benchmark story was: a 5-second video can render in under 3 seconds. The more interesting story is what developers started building once generation became faster than playback. They built television. The first demo got banned Fal engineer Rehan Sheikh connected H3 Max to a livestream inspired by the "interdimensional cable" idea from Rick and Morty. The important technical property was simple: generation time < playback time If the system can finish the next segment before the current one ends, the stream does not need to stop. The experiment went viral. It was removed from Twitch and then Kick. Rehan later said both platforms banned the stream within an hour. Instead of continuing to move between platforms, fal built its own. fal.live is interactive AI television fal.live is fal's experimental streaming platform. It currently exposes generated channels such as: Chaos Sitcom Anime Soap Opera Popcorn Availability is still experimental, and individual channels can pause or reconnect. The interesting part is the interaction model. Viewers are not just watching. They influence what happens next through prompts and voting. That turns the stream into a feedback loop: audience -> direction -> model -> generated scene -> audience reaction -> next direction 📺 That loop is much closer to a game engine than a traditional video file. Infinite Slop makes the idea even clearer Pieter Levels ( @levelsio ) built Infinite Slop with fal. The site describes itself very accurately: an endless AI-generated TV channel People type what they want to see next. Suggestions enter a queue. The system generates new scenes continuously. It is chaotic and often absurd, but I think the roughness makes the underlying shift easier to see. The audience is moving from spectator to input device. H3 Max Director is the real technical story The important release underneath these demos is H3 Max Director . A normal video gener

In August, we experienced five incidents that resulted in degraded performance across GitHub services. The post GitHub availability report: August 2026 appeared first on The GitHub Blog .

OpenAI has publicly outlined Defense Factory , a continuous, agent-first security operation designed to find, validate, and fix vulnerabilities across its own systems. The initiative grew from an internal security sprint in which OpenAI says it mobilized more than 250 people across hundreds of service areas with the urgency normally associated with incident response . Its importance is not the scale alone. OpenAI is presenting security work as a repeatable operating cycle rather than a periodic review. In OpenAI’s Defense Factory announcement , the company describes a closed-loop process supported by dedicated architecture and defender tooling. For organizations building with AI, the useful lesson is that hardening an AI deployment is not a one-time configuration task. It requires a clear inventory, a way to test suspected weaknesses, accountable owners, and proof that fixes worked. How OpenAI’s Defense Factory works A closed loop for vulnerability remediation OpenAI describes Defense Factory as a process that connects security findings to remediation instead of treating discovery as the final outcome. The company’s stated workflow has five linked stages: Inventory systems and service areas that need to be assessed. Discover potential vulnerabilities. Dynamically validate whether suspected issues are real and meaningful. Assign ownership so remediation has a clear responsible party. Verify remediation after a fix is made. That sequence matters because each stage addresses a common gap in security operations. An organization can have vulnerability reports without a complete view of relevant systems. It can also patch an issue without confirming that the remediation solved the original problem. By framing these activities as a continuous loop, OpenAI is aiming for a process that can be repeated as systems, integrations, and deployment practices change. OpenAI says its recent sprint became the origin of the broader Defense Factory program. The company characterizes the

À trois semaines de l'échéance du 30 septembre, beaucoup d'équipes de l'UEMOA écrivent du code de paiement dans l'urgence. La BCEAO a reporté à cette date la connexion à la plateforme PI-SPI pour les banques, les établissements de monnaie électronique et les établissements de paiement. Fin juin, 80 participants étaient connectés et 74 institutions encore en phase de test réel. Le Sénégal mène l'Union avec 20 institutions autorisées au 2 avril. PI-SPI règle l'interopérabilité entre institutions. Il ne règle pas ce que fait votre code quand un appel à Wave ou à Orange Money expire et que votre file de jobs le rejoue. C'est de ça que parle cet article, parce que c'est le bug que l'urgence produit et qu'on ne voit qu'en production, sur l'argent de quelqu'un d'autre. Le scénario, en trois lignes Un client valide sa commande. Vous appelez l'API du fournisseur. La requête met trente secondes, votre client HTTP abandonne, le job échoue, Laravel le relance. Le paiement est-il passé une fois ou deux ? La réponse dépend entièrement du fournisseur, et les trois que j'ai intégrés répondent différemment. MTN MoMo : une clé, et un piège dans sa réponse MTN est le seul des trois à fournir une vraie clé d'idempotence. L'en-tête X-Reference-Id sur POST /collection/v1_0/requesttopay , qui doit être un UUID. Si vous y mettez votre numéro de commande, l'API refuse sans expliquer pourquoi. Rejouez la même référence et MTN ne rejoue pas le paiement. Il répond : HTTP / 1.1 409 Conflict {"code": "RESOURCE_ALREADY_EXIST"} Le piège est là. Beaucoup de code PHP traite tout ce qui n'est pas 2xx comme un échec, et mon driver faisait pareil. Suivez alors le chemin complet : l'appelant subit un timeout, rejoue avec la même clé, reçoit un 409, voit une exception, conclut que rien n'est passé, et repart avec une nouvelle référence. Cette nouvelle référence est une nouvelle demande de paiement. Le client reçoit un second prompt. S'il valide, il paie deux fois. La clé a parfaitement fonctionné. C'est

Three parties describe the same roof and none of them can read the others' description. The town assessor's record says asphalt shingle, average condition, year built 1962 . A vision model looking at a satellite tile and a street-level photo says gable, moderate pitch, two planes, one chimney interrupting the north field . An estimator standing in the driveway says twenty-two squares, stick-framed, ring-shank sheathing nails, probably plywood over the original boards . All three are describing one assembly. There is no shared vocabulary between them, and the moment a fourth party arrives — a crew with a crane, or eventually a robot — the problem gets worse, not better. So the question: can a single grammar carry a roof from the assessor's record to a crew's cut plan to a machine's disassembly sequence without any party translating? ML Systems' bet is the Collective Ontology . What follows is the argument for it, made on the one assembly where it is easiest to check — and the admission at the end that it has not been checked. An assembly is a stack, and a stack has a direction A house is not one object. It is a set of assemblies — roof, walls, floors, foundation — and each assembly is a stack of layers applied in a known order. A roof is rafters, then sheathing over them, then underlayment, then shingles last. Each layer was fastened through the layer beneath it. The fastening is what makes four layers one structure, and it is also what destroys them when the structure is taken apart in the wrong direction. Two scales, and they run opposite ways: Scale Direction Order The building — between assemblies Reverse of construction Roof → walls → floors → foundation An assembly — between layers Inside out Innermost layer → outermost layer This is the thing most easily got backwards. A tear-off runs reverse order within the assembly — shingles first, because shingles went on last — and that is precisely the order that destroys everything, because every layer is broken throug

Google Analytics 4 has added a native way to identify traffic from recognized AI assistants. From May 13, 2026, GA4's Default Channel Group includes an AI Assistant channel, giving qualifying visits a dedicated medium, channel grouping and campaign value. The change makes it easier for marketers to see traffic from tools such as ChatGPT, Gemini, Deepseek, Copilot and Grok in standard acquisition reporting, rather than relying solely on custom rules. The new classification is important because AI assistants can increasingly influence how people discover websites. Until now, teams that wanted to isolate this traffic often had to build and maintain regex-based custom channel definitions. GA4's native grouping reduces that work for recognized sources, but it is not a complete solution to every AI-related attribution problem. What GA4's AI Assistant measurement changes Google documents the new channel in its GA4 Default Channel Group definitions . For visits GA4 recognizes as coming from an AI assistant, the platform applies three specific traffic-dimension values: Traffic dimension Earlier default reporting approach AI Assistant measurement from May 13, 2026 Medium No native ai-assistant assignment described ai-assistant Default channel group No AI Assistant channel described AI Assistant Campaign No native (ai-assistant) assignment described (ai-assistant) This means the relevant traffic can be examined through GA4's standard reports, including Acquisition reports and related channel dimensions. A marketing team can use the new channel to separate recognized AI assistant visits from Direct, Organic Search, Referral and other acquisition sources without first recreating source-recognition logic in a custom channel group. The scope matters. GA4 describes the channel as covering visits from recognized AI assistants, not every website session influenced by an AI tool. The classification depends on the information available when a visitor reaches the site. Why the change im

A "45% faster PR review" number is a great headline. The question is whether it means anything, because the post announcing it gives you no way to check. Atlassian's blog says Rovo Dev, their AI code reviewer, cut PR cycle time by up to 45% internally and 32% for customers. That's it. No methodology, no baseline definition, no sample, no how-the-slices-were-chosen. Just a number and a graph. That's not a knock on the product. It's a gap in the evidence. And the gap is exactly where this claim goes wrong when teams try to reproduce it. The first thing to ask is: 45% off what baseline? If your reference is "PRs that sat in the queue for three days waiting on a human nobody paged," then moving baseline checks to an AI that answers in minutes is going to look incredible no matter how good the reviews are. That's a queue problem being measured as a review problem. Once the backlog is gone, the 45% doesn't hold. Second, a single cycle-time aggregate hides the tail. A mean drops fast when the AI eats the easy set: the small, low-risk, well-documented diffs that a reviewer was already going to green-light quickly. The expensive PRs, the big architectural ones with real design risk, those still need human time and they still dominate the tail. Report p50 vs p95 and you'll see where the win actually sits. Third, and least glamorous: reviewer pool and busy-time matter. If the human reviewers on the measured team changed, or the team slowed its own review culture at the same time the tool shipped, you're attributing a confound to the tool. None of this is hard to fix. If you're a vendor publishing a PR-time win, or a buyer trying to validate one, run this and show the raw numbers: Pick a fixed window (two weeks feels about right, nothing shorter). Keep the reviewer pool fixed. No new hires, no reorgs. Split the window by PR size and by risk level, not just by the whole sample. Report median and p95, not just the mean. State what "baseline" means before the tool, and measure aga

Microsoft published the rare thing in this space: a first-party, attributed throughput number for AI code review. PRAssistant ran across 5,000 internal repos, covered 90%+ of PRs and 600K+ pull requests a month, and measured a 10–20% median improvement in PR completion time. Then it shipped externally as GitHub Copilot code review. That's worth slowing down on, because "median PR completion time" does real work in that sentence and people keep reading past it. What that metric captures is a throughput proxy. Code review is a queue: reviewers pick up a PR, read it, and merge it. Automation that screens for the obvious problems and unblocks trivial merges moves a strict majority of the queue much faster, which is exactly what a median improvement shows. It does not measure that the code is better. A reviewer who trusts the bot and merges faster, on code no human actually reasoned about, gets a faster merge and a worse product. The number can't tell the difference. That's not a critique of Microsoft. It's a caution for anyone who quotes the 10–20% as an argument that the tool catches more bugs. It changes when work starts, not necessarily what lands. The other part worth keeping is the scale language. 90%+ of PRs and 600K a month means they ran this only where it could keep up. PRAssistant is free to be picky about what it reviews because Microsoft's review volume is gigantic and the automation is boring; it wins by being available on almost everything. Then the rollout became Copilot code review, so the number is best read as a floor. What it did at Microsoft's volume is not a ceiling for what a smaller team should expect. The practical habit, if your team is about to adopt one of these: track review throughput and signal quality separately. Watch median time-to-merge on your side, sure. But also watch how many merged PRs came back with a regression or a follow-up fix six weeks later. One tracks speed, the other tracks whether the speed is real. Both are easy to measu

If you want the Rails implementation version of this, Webhooks in Rails goes deeper on verification, durable receipt, idempotency, retries, jobs, testing, and provider-specific behavior, and includes an Agent Companion for repo-aware coding agents. Already have webhook code in an existing Rails application? The free Webhook Architecture Checkup is a repo-aware prompt for tracing the flow you already have and finding the important gaps. Webhook endpoints always seem simple when you build the first version. Add a route, create a controller action, parse some JSON, update a record and return 200 . Pretty standard Rails stuff. Then the real requirements start showing up. You need to verify that Stripe or GitHub actually sent the request. The provider wants a response quickly, so the useful work moves into a background job. The same event arrives twice. A worker dies after doing half of the work. Two related events get processed at the same time. Another event shows up out of order. At some point, that little controller action has picked up a surprising amount of infrastructure around it. Nobody starts by saying, "I need a distributed system for this webhook." You normally get there one completely reasonable requirement at a time. It is still a small system, of course. We are not building Kafka and twelve services here. But once a webhook is production-ready, you have an external trust boundary, durable ingress, asynchronous workers, duplicate delivery, retries, concurrency, ordering problems and a handful of failure states that all need to agree with each other. That is the part of webhooks I find interesting. A tiny HTTP endpoint becomes a pretty good microcosm of a much larger distributed system. First, can you trust the request? A webhook is public ingress into your application, so before doing anything useful with the payload, you need to answer the obvious security question: did the provider actually send this? Most providers solve this with a shared secret and a s

Listen Labs walked away from a signed Series C term sheet from Menlo Ventures, sources say.