标签：#agi

My favorite metaphor for brutal cognitive dissonance — the one we will likely experience when the Singularity actually arrives — is “ the knight in the supermarket .” I prefer the word “chevalier,” though, so I’ll be using that going forward. Try to imagine the following scene: a medieval chevalier, somewhere on the land of current Germany, riding his horse, heavily armored, helmet on, big sword. The year is 1450, and our chevalier is just charging in a small battle against some equally armed neighbors. But then something happens. A short circuit in the space-time continuum and our chevalier is fast forwarded to the current times, but in the exact same location. Where, of course, there is a supermarket now. The lights. The shiny shelves with thousands of small, colored objects. The cold near the meat sector. The TVs rotating ads with faces of women talking in a slightly similar language, but saying words he cannot understand. At this moment, it’s safe to say that our chevalier is completely lost. He has no idea how light is made (no “electricity” concept in his mind), no way to know how cold is made inside a building (no “refrigerator”), no way to understand what the tiny packages on the shelves are (“chemistry” is closer to alchemy for him) and no way to understand remote communication (“television” doesn’t simply exist). He can still walk around, but the world will feel almost hostile to him. We’re Not in the Singularity. Not Yet Now let’s get back to the current X timeline, where everybody is screaming that we’re in AGI. In the Singularity. The world will never be the same. This changes everything. But does it, really? Are we experiencing the same cognitive gap as our chevalier in the supermarket? I don’t think so. The world is keep worlding right now, except for a very small percentage of people who are subjecting themselves to some AI-related psychosis. All we’ve done so far is cramming a LOT of compute into tiny digital artifacts that are nothing more than ver

Process mismatch In tools built for Scrum, a task is an input: something you file, size, and work on. In Shape Up, a task is an output — something discovered while building work that was already shaped and bet on. That's the core mismatch, and it plays out differently depending on the tool. Jira Jira does exactly what it was built to do. Its shape is Scrum's shape: a backlog, estimates, sprints. Teams bring Shape Up in anyway and try to make it fit the tool's shape. A scope becomes an epic. A task becomes a ticket. The pitch — Shape Up's document for a problem, its appetite, and a proposed solution — has no equivalent object in Jira, so it ends up living in a Confluence doc, disconnected from the work it's supposed to govern. The substitutions are each small and reasonable on their own: An estimate field is there, so it gets filled in — and the velocity report looks broken without it. Losing bets need somewhere to go, so they land in the backlog. They aren't dead, they're waiting — and now someone has to groom them. Appetite ("how much is this worth") quietly reverts to estimate ("how long will this take"). Before long, the team is running Scrum, with a backlog-refinement meeting back on the calendar. The tool's requirements pull the ceremonies back in. Linear Linear is fast and well made. It even has cycles. The mismatch here isn't a quality problem — it's an inheritance problem. Linear carries the same assumptions as Scrum, just executed better. When a cycle ends with work unfinished, Linear rolls it forward automatically into the next one. It's meant as a convenience feature. It's also the inverse of Shape Up's circuit breaker. Shape Up's bet is that the deadline is real. The whole mechanism depends on a hard stop forcing a decision — cut the scope and ship what's done, while there's still time to make that call. A tool that quietly carries unfinished work forward removes the one moment the method needs. Every six weeks, it says: the deadline was just a suggestio

I'm a scrum master. I was a developer ten years ago. I have enough background to discuss design and trade-offs with an LLM — but three months ago I made a deliberate bet on my solo project: I would never read the code. The specs define the tests. The tests control the code. The code is a black box. I'm not claiming this is what everyone should do. But it's my bet, and it forced a system into existence: when nobody reads the code, the process has to carry the trust that a code-reading human normally provides. I've just published that system as a reference implementation: backlog-as-data — the full writeup, the Claude Code skills translated to English, and the CLI source, verbatim from my daily setup. Here's the short version. The backlog is git data, not a document Most agent task-management tools store tasks in a dedicated place — a tasks.json , a database, a backlog/ folder. My bet is different: the backlog is the YAML frontmatter of my spec files. One file per ticket, and the ticket's status is a field — never a location in a document. --- id : PARSE-07 title : Tolerate CRLF in decklist import type : ticket status : todo priority : should exec : model : sonnet effort : think review : light matured : 2026-07-22 --- # PARSE-07 — Tolerate CRLF in decklist import The spec body: design, contracts, test cases. The ticket file IS the spec. Everything below the frontmatter is the spec — written by the LLM, after it has challenged the need I expressed in conversation. The frontmatter is data — owned by a small CLI, mutated only through it. Same file, so they can never drift apart. Why it matters: "move it to Done" is not an operation. LLMs (and humans) mangle documents when a state change means relocating text. Making status a field makes every transition a one-line, idempotent, testable mutation. The board I look at (a small web page on my server, with GitHub deep links to each spec) and the readable markdown view are generated projections , locked by a do-not-edit sentin

Every team I've worked with has a version of the same Slack message. Someone posts a PR link, adds a...

Agility is opening a new training center for its Digit robots in Fremont, California.

There’s more to Google’s messaging app than you might realize.

AI Doesn’t Replace Agile. It Makes Good Agile More Important. The discussion around AI replacing Agile is becoming increasingly common. The argument usually goes something like this: Information is now instantly accessible. Code can be generated in hours instead of weeks. Documentation is no longer expensive to produce. Communication overhead is dramatically reduced. If all of that is true, do we still need Agile? I believe the answer is yes—but perhaps not in the way we practice it today. The mistake is assuming Agile is defined by stand-ups, sprint planning, retrospectives, or two-week iterations. Those are practices, not principles. The real purpose of Agile has always been much simpler: Deliver customer value incrementally while maintaining enough structure to ensure quality, accountability, and continuous learning. That objective hasn’t disappeared because AI became faster. AI Changes Execution, Not Responsibility Large language models can generate code, documentation, tests, infrastructure, and even architecture proposals. What they don’t generate is accountability. In enterprise environments—especially regulated industries—the question is rarely “Who wrote this code?” The real questions are: Who owns this decision? Why was this solution selected? Can we trace how we arrived here? Can we audit the process? Who is responsible when something fails? Without clear ownership and controlled handoffs, AI can produce enormous amounts of output that become increasingly difficult to understand, validate, or maintain. Speed without governance simply creates technical debt faster. Coordination Isn’t Going Away Many people assume AI eliminates the need for coordination. I would argue the opposite. As AI agents begin collaborating with humans—and eventually with other AI agents—the need for explicit coordination actually increases. Someone still needs to define: objectives, responsibilities, interfaces, quality gates, acceptance criteria, governance, and success metrics. Th

Un’area interna che sembra una lavagna di ragionamento: non è coscienza, ma è un indizio forte su come emergono controllo e pianificazione nei transformer. Negli ultimi anni ci siamo abituati a pensare ai modelli linguistici come a enormi “scatole nere”: un prompt entra, un testo esce, e nel mezzo c’è un mare di matrici difficili da ispezionare. Ma c’è una novità interessante: alcune analisi suggeriscono l’esistenza di una piccola regione interna, relativamente organizzata, che funziona come uno spazio di lavoro per concetti . Un posto dove il modello “tiene a mente” qualcosa prima di produrre la risposta. È un’idea che fa scattare subito l’associazione più pericolosa (e più abusata) del momento: coscienza . In realtà, il punto non è stabilire se un LLM sia cosciente; il punto è molto più concreto e utile per chi sviluppa: se esiste un’area interna che concentra il ragionamento controllabile , allora possiamo capire meglio cosa guida certe risposte e come intervenire su errori, allucinazioni e comportamenti indesiderati. J-Space: una “lavagna” interna per il ragionamento L’idea chiave è questa: dentro il modello emergerebbe un piccolo insieme di pattern neurali “coerenti” (chiamiamoli J-Space ) che si comporta come una lavagna. Su questa lavagna compaiono concetti (non necessariamente parole che verranno stampate). Questi concetti influenzano la catena di ragionamento . Molte altre abilità—fluency, grammatica, stile, completamento locale—sembrano invece scorrere “automaticamente” altrove. Se questa separazione regge, spiega un fenomeno che tutti abbiamo osservato: modelli capaci di scrivere in modo impeccabile, ma fragili nel ragionamento o incoerenti quando devono mantenere vincoli. Il test più interessante: sostituire un concetto e vedere il ragionamento obbedire Un esperimento illuminante consiste nell’individuare un concetto attivo nello spazio di lavoro e sostituirlo con un altro, senza cambiare né prompt né output manualmente. Esempio (semplificato): Domanda:

Async processing qua message queue: vì sao đẩy việc nặng ra khỏi request path, và cái giá phải trả bằng eventual consistency Async processing là mô hình tách một request thành hai giai đoạn: request handler nhận việc, xác nhận với client, rồi giao phần xử lý thật cho một worker chạy ngoài request path — thường qua một message queue (RabbitMQ, AWS SQS, Kafka, Redis Streams, hoặc queue trên nền Redis như BullMQ/Sidekiq). Lý do dev gặp nó trong việc thật rất cụ thể: một endpoint gọi payment provider mất 3s, gửi email confirm mất 1s, resize ảnh mất 5s — nếu làm tuần tự trong request, p99 latency của endpoint là tổng các con số đó, và một downstream chậm hoặc chết đủ để làm timeout hết thread pool của app server. Đẩy vào queue thì request trả về trong vài chục ms; nhưng đổi lại, cái "xong" mà client thấy không còn nghĩa là việc đã thực sự hoàn thành. Cơ chế hoạt động Ba thành phần: producer (thường là API server) đóng gói việc thành message rồi publish vào broker; broker (RabbitMQ/SQS/Kafka…) giữ message trong queue có persistence tuỳ cấu hình; consumer/worker poll hoặc được push message, xử lý, rồi ack để broker biết xoá. Nếu worker chết trước khi ack, broker redeliver — đây là gốc của semantic at-least-once : mỗi message được giao ít nhất một lần, có thể nhiều lần. Exactly-once trong hệ phân tán chỉ đạt được ở lớp application bằng cách consumer viết idempotent, không phải bằng cấu hình broker. Ví dụ với RabbitMQ + Node ( amqplib ): // producer — trong HTTP handler const ch = await conn . createConfirmChannel () await ch . assertQueue ( ' image.resize ' , { durable : true }) app . post ( ' /upload ' , async ( req , res ) => { const jobId = crypto . randomUUID () const payload = Buffer . from ( JSON . stringify ({ jobId , s3Key : req . body . key })) await ch . sendToQueue ( ' image.resize ' , payload , { persistent : true , // ghi xuống disk, sống sót broker restart messageId : jobId , // để consumer dedupe contentType : ' application/json ' , }) // đợi broker confirm đ

Top robotics researchers and founders explain how robot autonomy is evolving.

Top robotics researchers and founders explain how robot autonomy is evolving.

While other humanoid startups chase sky-high valuations, Agility Robotics is betting its future on execution — and a SPAC.

Middleware in PAGI A port of the sample app from What Is Middleware? — which builds the same three-layer stack in Plack/PSGI (Perl) and Starlette/ASGI (Python) — to PAGI , an async, ASGI-style application interface for Perl. The app is deliberately tiny but exercises the three things middleware exists to do: Logger — wrap the request, time it, log method/path in and status/duration out. Authenticator — inspect a header, inject context for downstream layers on success, or short-circuit with a 401 on failure. ProfileRouter — answer one specific route from inside the stack, reading the context the Authenticator injected. All code below was run under perl-5.40.0 with PAGI::Test::Client ; the log lines and responses shown in Running it are the actual captured output, not hand-written. The PAGI middleware contract A PAGI application is, in the spec's words, "a single coderef returning a Future": an async sub over the ($scope, $receive, $send) triple — the same shape as ASGI. $scope is the per-connection metadata hash ( type , method , path , headers , …), $receive pulls inbound events, $send pushes outbound ones ( http.response.start , then http.response.body ), and the Future it returns resolving is what tells the server the response is complete. Middleware is just as plain: a subroutine that takes an application and returns a new application, wrapping the inner one. That is the whole spec-level contract — app in, app out: sub middleware { my ( $app ) = @_ ; return async sub ($scope, $receive, $send) { # ... before ... await $app -> ( $scope , $receive , $send ); # call the inner app # ... after ... }; } A middleware propagates the inner app's Future — its completion and any exception flow straight through — and never reads its return value, which the spec defines as inert; to observe or rewrite the response it wraps $send instead, and to add per-request context it clones $scope (top-level edits stay visible downward only). PAGI::Middleware , from PAGI-Tools rather than

Nvidia has dominated the AI chip market for years, but the era of total dependence might be ending. OpenAI just shared its plans to spice things up with Jalapeño, its custom inference chip built with Broadcom, joining Google, Apple, and SpaceX in a growing list of companies building their way out of single-supplier risk. The goal is less of a […]

The small bit of air in the bottle sees oxygen and other chemicals move in and out.

Agility Robotics, the humanoid robotics startup that spun out of Oregon State University in 2015, expects to generate $620 million in proceeds.

Devices that monitor seniors for safety are appealing to worried loved ones and underresourced home care agencies.

From Scratch: How to Integrate Reasonix CLI into the HagiCode System This article shares the complete technical practice of integrating Reasonix CLI as a first-class Agent Provider into the HagiCode system, covering three-layer architecture design, key technical decisions, and frontend and backend implementation details. Background Reasonix CLI, as it happens, is a pretty interesting thing. It's an AI code assistant tool based on ACP (Agent Communication Protocol), providing powerful streaming and session management capabilities. Actually, in the HagiCode.Libs layer, we've already completed its underlying implementation. It's just that these components are still in an isolated state, like beautiful pearls that haven't been strung into a necklace. Users cannot use it through Hero profession selection, session execution paths, or monitoring panels, which is somewhat regrettable. The problem we face is: how to elevate Reasonix to the same level as Codex, Hermes, and other first-class Agent Providers, implementing complete backend routing and frontend display? This isn't simply a matter of registering an enum value. It requires building a complete chain from low-level abstraction to user interface. It's like building a house—you can't just lay a foundation and call it done. You have to build the walls and put up the roof. The challenge of this integration lies in the fact that Reasonix, as a local CLI tool, has its own personality and temperament. For example, it doesn't need a connection string—all parameters are configured by the user at runtime; it might not even be installed, requiring graceful degradation; it's compatible with anthropic series models, but also has its own ACP-specific parameters like effort, budget, and so on. It's like a person with their own unique way of handling things—you can't force it. After careful architectural design and multiple rounds of discussion, we finally adopted a clear three-layer architecture solution, successfully integrating R

I said "maybe a couple days" on a call last Tuesday. By Wednesday morning it was in a Jira ticket as "2 days." By Thursday afternoon somebody was checking in to see if we were tracking against the two day commitment. Nobody did anything wrong. The person who wrote it down was capturing what I said. The person checking in was doing their job. I was the one who said the words. The system worked exactly as designed. The system is the problem. Something Ive learned is that theres no such thing as a rough number in meetings today with all of the AI note takers... The moment you say a number out loud, it stops being a feeling and starts being a quote. The hedge in front of it doesnt survive the transcription. "Maybe" disappears. "Couple" gets rounded to a specific integer. "Give or take" is the first thing that hits the cutting room floor. What lands in the document is the number, naked, with no caveats and no error bars. Everyone in the meeting heard what you heard. They heard the hedge. They watched you wave your hands. They understood, in the moment, that you werent committing. But the document doesnt remember any of that. The document just remembers the number. And the document outlives the conversation, which is where all the nuance lived. Ive watched myself do this for years and I still get caught by it. Someone asks how long something will take. I want to be helpful. I want to seem confident. I want to keep the meeting moving. So I say a number. The number is approximately right, or at least I think it is, but I havent actually thought about it the way you would think about it if you were going to commit to it. By saying it out loud, Ive committed to it. The fix, if theres one, is to refuse the number. Not rudely. Just clearly. "I need to look at it before I give you a real number. I can have one for you by Friday." This works about half the time. The other half, somebody in the room is going to ask you for a ballpark anyway, and youre going to give them one, and t

InfoQ celebrates its 20th anniversary. To mark the occasion, we have published a walk-through of the trends InfoQ called early, where they sit on the adoption curve today, and how that curve may evolve over the next decade. By InfoQ