DevOps · PiniShv

Agentic Overwatch: Why Your Next Dev Team Will Look Like a NASA Control Room

Mon, 01 Jun 2026 21:00:00 +0300

It’s 3:00 AM and a dozen screens are still on. Most of the company is asleep. A few people aren’t, because the systems they watch don’t keep office hours. A graph spikes red, someone acknowledges the alert, a fix goes out, the line settles back to green. Then the next one.

Early in my career I spent less than a year inside a Network Operations Center like that. Short stint, but it stuck with me. We kept thousands of live servers running in real time, 24/7. When something broke at 3:00 AM we didn’t file it for the morning stand-up. We fixed it then and there. We were the failsafe, and the failsafe doesn’t get to sleep through the incident.

I keep coming back to that room, because I think it’s where the whole software industry is heading. Not just engineering. All of it.

Here is the part most people haven’t clocked yet. The agents everyone is so excited about don’t only write code. Inside the organizations that are actually leaning in, one agent is rebalancing cloud spend before the monthly bill blows the budget. Another just quarantined a leaked token and is drafting the security writeup. A third is rewriting the flaky test suite that’s been blocking the release train. A fourth shipped the incident postmortem before the humans woke up. A fifth is halfway through a customer’s support ticket. None of them asked permission. Every one of them is doing work that used to belong to a person with a title.

That isn’t a dev team anymore. It’s a workforce. And almost nobody has a single screen that shows what the whole workforce is doing right now.

We are handing autonomous agents the keys to engineering, operations, security, QA, data, and support, at a velocity no human team can match. And we are still governing them with the model we built for hand-typed software: nine to five, five days a week, with a fragile on-call rotation taped to the side. We still expect a tired human to “step up” at 2:00 AM and babysit production.

That expectation was already shaky when humans wrote all the code. It snaps the moment the code, the infra changes, the security responses, and the test rewrites all start writing themselves.

You cannot govern a workforce that runs flat out, around the clock, with a team that logs off at 5 PM.

We are entering the era of Agentic Overwatch.

Defining the term
#

I want to say plainly what I mean, because the industry keeps gesturing at this without naming it.

Agentic Overwatch is the discipline of supervising a fleet of autonomous AI agents in production the way an operations center supervises live infrastructure. A NOC watches uptime. A SOC watches threats. Agentic Overwatch watches the agents themselves, whatever function they happen to be performing, and keeps a human in the loop for the decisions that carry real consequences. Continuous, tiered, shift-based. The unit of work is no longer a line of code. It is the fleet, and the human’s job is to steer, judge, and authorize rather than type.

That is the whole idea. Everything below is the architecture of it.

The room needs a name too, because it earns one. A NOC is a Network Operations Center. A SOC is a Security Operations Center. This is the Agent Operations Center, the AOC, and the people who staff it are the AOC team. That is what I mean every time I say “the room” from here on.

A couple of things it gets confused with, so let me clear them out of the way.

It is not AIOps or observability. Those tools watch your systems and surface anomalies for a human to go fix. Overwatch watches your agents, the workers that are themselves taking action, and a human approves or vetoes what they propose. The thing under supervision moved up a level. Your dashboards used to show you CPU and latency. Now they have to show you what your workforce is deciding to do about CPU and latency.

It is also not vibe coding. Vibe coding is the casual, almost magical act of prompting an AI to spit out an app while you sip your coffee. Fun trick. It completely ignores what happens after the demo, when that code scales and thousands of agents are making real decisions in a live environment at once. Vibe coding is about generating. Overwatch is about governing. They are not in the same job family.

And to head off the obvious question: yes, a few security vendors ship products with “OverWatch” in the name for threat hunting. This is broader than any one product. Agentic Overwatch is not a thing you buy. It is the operating model for supervising your whole agent fleet, whatever job it happens to be doing.

It was never just about code
#

The phrase “AI writes code” undersold this from the start. Code was simply the first job agents got good enough to take.

Watch where they spread next, because it is already happening. In operations, agents scale services up and down, reroute traffic, and roll deployments back when error rates climb. In security, they triage alerts, revoke credentials, and isolate compromised workloads. In QA, they generate tests, reproduce bugs, and gate releases. In data, they fix broken pipelines and backfill tables. In FinOps, they hunt down waste and right-size infrastructure. In support, they resolve tickets that used to sit in a queue for two days. Each of these is a function that an entire team used to own. Now an agent owns a slice of it, and the slice keeps growing.

I wrote a while back about putting AI agents on the org chart, with real owners and real KPIs. The point lands harder now. If agents staff every function, then the most dangerous failures are not the ones inside a single function. They are the ones that cross between them. The cost agent right-sizes a database at the exact moment the deploy agent ships a migration against it. The security agent revokes a service account that, three systems away, runs the nightly billing job. No single team owns that collision. No single dashboard sees it coming.

That is why this has to be one room watching one fleet, not five tools watching five corners. The whole reason the NOC worked was that it sat above the silos and saw the system whole.

The governance gap
#

Output is compounding across every one of those functions. Oversight is flat. I made this point about code specifically, but the curve is identical for deploys, security responses, and data changes: we can produce far faster than we can supervise.

That is the governance gap, the widening distance between how much autonomous work is happening and how much human oversight actually covers it. We are treating agents like a brilliant intern we leave alone in the building overnight. Never sleeps, never tires, ships to production on its own schedule, and nobody is watching while it does. Shadow AI already proved teams will wire up unsupervised agents faster than leadership can react. This is not a forecast. The gap is in your stack tonight.

When those agents trigger a cascading failure at 3:00 AM, and eventually they will, “we were all asleep” is not a line you want in the postmortem. Closing the gap is not a tooling purchase. It is a change in how teams are built and how they run the clock.

Borrow the tier model from the NOC
#

Here is what the NOC got right decades ago, and it maps onto agents almost perfectly. Operations has always run in tiers. Agentic Overwatch keeps the structure and changes who sits in each chair.

Tier 1, detection and triage. Agents. They watch every signal across every function, correlate the noise, classify severity, and kill the false alarms that used to wake people up for nothing.

Tier 2, diagnosis and remediation. Agents. They reproduce the failure, trace the blast radius, draft the fix, write the rollback plan, and stage it. This is the work that used to eat a senior engineer’s entire night.

Tier 3, judgment and authorization. Humans. Not because we are faster, but because we own the consequences. This is the split-second call that actually carries weight: “Agent 4 found a memory leak in the payment gateway and wants to roll the database back. Approve or reject?” Or the one that crosses functions: “The security agent wants to revoke this service account to contain a breach. It also runs tonight’s billing. Approve or reject?”

Agents do the work in Tiers 1 and 2. Humans own the call in Tier 3.

The leverage is obvious once you see it. Tiers 1 and 2 were always the exhausting, repetitive, sleep-wrecking tiers, and those are exactly the tiers agents are best at. The human moves up to Tier 3, where the work is rare, consequential, and human by nature.

The agents do the work. The humans own the call. That is the entire operating model, and it fits on a sticky note.

The human becomes the orchestrator
#

So what is left for the human in the loop? Everything that actually matters.

The people in the Overwatch room are orchestrators. They don’t write the hotfix, because the agent already wrote three versions of it. They bring the judgment, the context, and the boundaries the agent doesn’t have. They decide which proposal ships and which one gets killed before it touches a customer.

This is the thread I keep pulling on. I’ve written about AI reviewing AI’s code and about orchestrating multiple agents when one isn’t enough, and I’ve argued that the IDE is becoming mission control. Every vendor is rebuilding its product around the agent rather than the file. Overwatch is what that mission-control surface is finally for. Walk into one of these rooms in a few years and you will not see engineers hunting for a missing semicolon. You will see a wall that tracks the live workflows, decision trees, spend, and health of thousands of agents across every department, and a small number of very sharp people steering it.

The Overwatch engineer is part SRE, part reviewer, part air traffic controller. The scarce skill is not typing speed. It is the calibrated judgment to know when an agent’s confident-looking fix is about to make everything worse.

For this to work, the culture has to borrow the operational rigor of those old NOC rooms. The artisan era of software is giving way to an industrial one, and industrial operations do not go home at 5 PM. The 9-to-5 gets replaced by continuous, shift-based orchestration. Follow-the-sun, the way global operations have run for decades. Nobody wakes a single exhausted developer at 2:00 AM. A fresh, fully alert Overwatch engineer on the AOC team catches the agent’s proposed fix and authorizes the deploy before the customer ever sees a glitch.

The handoff: ownership changes hands at the end of the day
#

A NOC shift never ends with everyone just going home. It ends with a handoff. The outgoing team tells the incoming one what is running, what is fragile, what to watch, and what to do if it breaks. Agentic Overwatch needs the same ritual, and it is the piece most teams will forget.

When a developer wraps for the day, they should not close the laptop and hope their agents behave overnight. They hand ownership of their in-flight work to the AOC team. Not “keep an eye on things.” Actual ownership: these agents are mine, here is what they are doing, and from now until tomorrow morning they are yours to steer.

What makes that handoff real is the runbook. For every agent or workstream a developer hands over, there is a short, blunt document that answers the questions the AOC team will actually face at 3:00 AM:

What is this agent doing, and what does normal look like?
What are the failure modes, and how do I tell them apart?
For each scenario, what is the AOC authorized to do on its own? Approve the rollback? Pause the agent? Reroute traffic? Page the owner? Or just log it and wait?
What must never happen without waking me up?

This is what lets a human who did not write the code still own the call. A good runbook turns “I don’t know, it isn’t my code” into “the runbook says approve the rollback, so I approve it.” Without runbooks the AOC can only watch and escalate, which means you are right back to waking people at 2:00 AM. With them, the room can act with the same confidence the author would have had.

So the definition of done changes.

A feature is not done when the code merges. It is done when the AOC can run it without you.

The runbook becomes part of shipping, the same way tests and docs are. If you cannot hand your agent off with a page that tells a stranger how to govern it at 3:00 AM, you have not finished building it. You have just stopped typing.

The Overwatch Maturity Model
#

If you want to know where your team actually sits today, and where it needs to go, here is the curve. Borrow it, argue with it, cite it.

Level 0, blind. Agents do real work, humans review during business hours, and nobody watches what runs overnight. Most teams are here and don’t know it.

Level 1, alerting. Agents act, and when something breaks they page a human who logs in and fixes it by hand. The on-call rotation with extra steps. Still reactive, still wrecking someone’s sleep.

Level 2, assisted remediation. Agents detect, diagnose, and propose fixes. A human reviews the proposal and approves execution. Tier 3 exists, but coverage is patchy and tied to working hours.

Level 3, continuous Overwatch. Shift-based human coverage, agents running Tier 1 and Tier 2 around the clock, and a real authorization layer for consequential actions. The room is staffed whenever the agents are working, which is always.

Level 4, orchestrated fleet. Overwatch itself is the discipline the company is organized around. One view across thousands of agents in every function, codified escalation policies, agent KPIs, and humans whose entire job is steering the swarm. This is the control room.

Almost everyone is at Level 0 or 1. The point is to stop pretending otherwise.

The honest answer for almost everyone reading this is Level 0 or 1. The point is not to leap to Level 4 next quarter. It is to stop pretending you are further along than you are.

How to start before your agents force the issue
#

You do not need a war room with floor-to-ceiling monitors next week. You need to start building the operational muscle now, while the stakes are still survivable.

Map your autonomy honestly. Write down every place an agent already acts without a human in the loop, across every function, not just engineering. The list is longer than you think, and the surprises on it are your real risk.
Define the authorization boundary. Decide which actions an agent runs freely and which require a human first. Payments, migrations, credential changes, anything that can take down the service or leak data: agent recommends, human approves, agent executes.
Instrument the agents, not just the systems. You need a view of what your agents are deciding, not only what your servers are doing. If you cannot see the fleet, you cannot steer it.
Write the runbooks, and make them part of done. For every agent a developer hands off, ship a page that tells whoever is on shift what normal looks like, what the failure modes are, and exactly what they are allowed to do about each one. No runbook, not done.
Staff the clock, not the calendar. Start small. Even a thin follow-the-sun rotation across two or three regions beats one time zone pretending production sleeps.
Give the room real authority. An Overwatch engineer who cannot veto an agent or halt a deploy is not doing Overwatch. They are a spectator with a nice dashboard.

The teams that build this muscle now will run hybrid fleets calmly while their competitors are still getting paged at 3:00 AM and writing apologies in the morning.

The fleet doesn’t sleep
#

The agents never tire. They never log off. Soon our operational models won’t either.

The move from artisan to operator is not optional, and it is not far off. It is the difference between governing your agents and being governed by their failures. The companies that win the next decade will not be the ones that generate the most code, or close the most tickets, or ship the most deploys. They will be the ones that can watch the whole fleet do all of it: continuously, calmly, around the clock.

Stop writing lines of code. Start commanding the fleet.

Welcome to the era of Agentic Overwatch.

I lead Innovation for a global SaaS platform, and I spend my time on one question: how do teams get dramatically more out of the people and tools they already have? Agentic Overwatch is my own thesis about where that goes next, and it is what I have been preaching to anyone who will listen. If it resonates, or you are just realizing you are sitting at Level 0, I want to hear about it. Find me on X, LinkedIn, or Telegram. And if you start using the term, you know where it came from.

100 Days to the EU AI Act Deadline. Your Engineering Team Hasn't Started.

Fri, 24 Apr 2026 16:00:00 +0300

Today is April 24, 2026. The EU AI Act’s enforcement deadline for high-risk AI systems is August 2, 2026. That’s exactly 100 days.

In most engineering organizations, the legal team is tracking this. The compliance team is tracking this. The engineering team has not been formally told what they need to ship by August.

By July, that gap will not be recoverable. Not because the work is impossible. Because the work requires sprint capacity that wasn’t planned for.

Who this actually applies to
#

Before anything else, kill the myth that this is “a European company problem.”

The EU AI Act applies extraterritorially. If your AI system is used by EU citizens, you are in scope regardless of where your company is headquartered. US-based SaaS with EU customers? In scope. Israeli startup selling to a German bank? In scope. AI feature in a product that’s accessible from Europe at all? In scope. Your B2B API is called by someone else’s product that serves EU users? Still in scope. Downstream distribution doesn’t insulate upstream providers.

There’s no “I didn’t know” exemption. Fines go up to €35 million or 7% of global annual revenue, whichever is higher.

If you have any customer traffic from the EU, even indirect traffic through a partner, this is your problem.

What the law actually requires (in engineering language)
#

Each critical article, translated into changes in your repo.

Article 50: Transparency
#

Law: Users must be told when they’re interacting with an AI. AI-generated content needs machine-readable markers and metadata.

Engineering translation:

Add a visible UI disclosure anywhere users interact with an AI-driven feature. Not buried in the terms of service. In the flow.
Attach machine-readable metadata (HTTP headers, EXIF-equivalent content tags) to any AI-generated content your system produces or distributes.
For chat interfaces, a persistent “AI assistant” label near the input field is the minimum.

What this means for your sprint: audit every product surface where a model output reaches a user. Every single one. Add disclosure if missing. Add metadata tagging if content leaves your system.

Article 12: Record-keeping
#

Law: Every interaction with a high-risk AI system must be logged in a structured, auditable format that a regulator can query.

Engineering translation:

Structured event logging on every model inference. Inputs, outputs, model version, timestamp, user or tenant identifier, confidence scores if available.
The log must be queryable. A 12-month pile of unstructured stdout does not count.
Retention needs to match the regulatory requirement (typically 6 years for high-risk systems).

What this means: if your current AI feature logs to stdout or to a generic app log, that’s not compliant. You need a dedicated audit trail with a proper schema, proper indexing, and retention guarantees.

What this costs: this is the one that eats the most sprint time. Log schema design, storage tier pricing, indexing for query performance, access controls on the audit store. If you’re starting in April for an August deadline, you’re already tight.

Article 14: Human oversight
#

Law: Sensitive AI decisions need a defined path for human review before taking effect.

Engineering translation:

Identify the decision points where AI output influences high-risk outcomes (hiring, credit, healthcare, legal, education, critical infrastructure).
At each of those points, there must be a deterministic path that routes the decision to a human before the outcome is final.
The human must have the actual ability to override the AI’s suggestion, not just acknowledge it. “Click to confirm” with no real friction doesn’t count.

What this means: your AI features that auto-approve, auto-reject, or auto-route need a human gate if the outcome is classified high-risk. The gate has to be real, with a real UI, real authority, and real training for the humans using it.

Article 5: Prohibited practices
#

Law: Some AI uses are outright banned. Social scoring of individuals by public authorities, exploitative manipulation of vulnerabilities, certain biometric categorization, real-time remote biometric ID in public spaces.

Engineering translation:

Content policy filters on inputs before they reach your models.
A classification layer that recognizes and blocks prohibited use patterns.
Documentation showing how you prevent your system from being used for prohibited purposes.

What this means: for most engineering teams, this is the smallest implementation lift, unless you’re in a directly affected industry (HR tech, surveillance, credit scoring, biometrics). The documentation burden is still real. Auditors will ask for your prohibited-use risk assessment even when your answer is “we don’t do any of this.” “We don’t do that” is an answer that requires evidence, not a shrug.

Why the legal team isn’t the bottleneck
#

The legal teams have been on this for a year. The compliance frameworks exist. The consultants are getting 20 to 30% of the budget pie for certification-related work. Vendors are already passing costs through with visible markups.

None of that ships code.

The bottleneck is engineering sprint capacity that was never allocated. Specifically:

Audit log infrastructure (Article 12) is an engineering-heavy build
Human oversight UIs (Article 14) need product and front-end work
AI feature disclosure (Article 50) needs coordinated UX across every surface
API inventory and risk classification (prerequisite for all of it) requires engineering time to map

In organizations doing this well, someone senior on the engineering side already took the brief from legal and translated it into specific issues in the backlog before the end of Q1 2026. If that hasn’t happened in your org yet, somebody needs to do it this week.

The 100-day plan
#

Here’s the realistic minimum. Compress if you have less time. Don’t expand if you have more, because you don’t.

Days 1 to 15 (now through May 9): Inventory and triage
#

Complete API inventory of every AI-involved endpoint your systems call, produce, or expose.
Classify each endpoint by risk level under the Act (minimal, limited, high-risk, prohibited).
Name an engineering owner for each high-risk surface. Not the CTO. An actual engineer who’s going to do the work.

If you do nothing else in the next two weeks, do this. Everything else depends on it.

Days 16 to 50 (May 10 through June 13): Build the audit layer
#

Design and ship a structured event logging system for high-risk AI interactions.
Retention policy, schema, indexing, access controls. All of it.
Backfill where you have data. Don’t backfill where you don’t, but document the gap.

This is where your engineering budget goes. If you’re outsourcing one thing, outsource the rest so engineering can focus here.

Days 51 to 80 (June 14 through July 13): Disclosure and oversight
#

Add AI disclosures across every relevant product surface.
Add machine-readable metadata to AI-generated content.
Ship the human oversight UIs for high-risk decision points.

This is where product and design need to stop saying “it doesn’t affect this quarter’s roadmap.” It does now.

Days 81 to 100 (July 14 through August 2): Documentation and dry-runs
#

Complete the technical documentation required for your risk classification.
Run internal dry-runs of a regulator query. Can you actually produce the audit trail for a specific user’s specific interaction from four months ago? If not, fix it now.
Train the humans doing the oversight role. They need to understand what they’re reviewing.

The one thing that blows up the plan
#

If you’re an engineering leader reading this in April, you have time. If you’re reading this in July, you don’t. The honest answer at that point is to either pull high-risk AI features off your EU-facing product or accept that your first enforcement cycle will go badly. Better said out loud now.

What to do this week
#

Three things, in order.

Monday morning: one-hour sync between your most senior engineer and your most senior compliance person. Leave with a shared doc listing every AI-involved product surface. Share with the CTO or VP Eng by end of day.

By Thursday: classify every surface (minimal, limited, high-risk, prohibited). For high-risk ones, name an engineering owner.

By Friday: the audit-log infrastructure team exists and knows what they’re building. Even if it’s two people. Even if one of them is borrowed from a platform team. The work starts now or it doesn’t finish.

The EU AI Act isn’t a future problem anymore. It’s a planning problem you have this week. It’s also where the longstanding gap between how fast organizations produce AI code and how slowly they govern it finally gets priced. In fines. In front of regulators. Most orgs will not realize that until too late. The ones that do now get to ship on time.

If you’re already working on this, I’d love to hear what’s surprised you. If you haven’t started, forward this to whoever decides sprint priorities. Find me on X, Telegram, or LinkedIn.

Disclaimer: This article references the EU AI Act and related compliance materials for illustrative and educational purposes. It is not legal advice. You should consult a qualified legal team for compliance specifics in your jurisdiction and industry. Articles, deadlines, and classifications referenced are based on publicly available sources at the time of writing and may change. The opinions expressed are my own. I have no financial interest, business relationship, or affiliation with any specific compliance vendor mentioned. This is commentary, not legal, investment, or business advice.

OpenClaw Is Not a Chatbot. It's a Personal Agent Gateway.

Thu, 19 Mar 2026 14:00:00 +0200

Think about how you use AI right now.

You open a browser tab. You go to ChatGPT or Claude. You type something. You get a response. You close the tab. Tomorrow you open it again and start from scratch. Maybe you remember to use Projects. Maybe you don’t.

Now think about how you communicate with your actual team. WhatsApp. Telegram. Slack. Discord. You don’t open a special app to talk to people. You message them wherever you already are, and the conversation continues across devices and time zones.

OpenClaw is built on a simple bet: your AI assistant should work the same way. Not in a browser tab. In the places you already are. Always on, always reachable, always remembering what you talked about yesterday.

That sounds like a small UX difference. It’s not. It changes what an AI assistant can actually do for you.

What OpenClaw actually is
#

Let me be clear about what this is and what it isn’t. The project’s own FAQ is blunt: it is not “just a Claude wrapper.”

OpenClaw is a self-hosted gateway that connects AI agents to your messaging channels. WhatsApp, Telegram, Slack, Discord, Google Chat, Signal, iMessage, WebChat. Plus a browser Control UI and companion apps for macOS, iOS, and Android.

The GitHub repo has roughly 325k stars, which makes it one of the largest open-source AI projects out there. But the star count isn’t the interesting part. The interesting part is the architecture.

The Gateway is the single source of truth for sessions, routing, and channel connections. It embeds the Pi SDK directly instead of shelling out to a subprocess, which lets it inject custom tools, tune prompts by context, persist sessions, rotate auth profiles, and switch model providers on the fly. On top of that, ACP (Agent Communication Protocol) lets it hand work off to external coding-agent runtimes when that makes more sense.

In plain English: OpenClaw is not one model with one UI. It’s a routing and orchestration layer that sits above models, tools, channels, and state. The assistant is the product. The Gateway is the infrastructure.

Why this is different from browser-based AI
#

I wrote about Open WebUI recently. Open WebUI moves the AI interface from a vendor’s SaaS into your own self-hosted browser workspace. That’s valuable. But OpenClaw takes a different bet entirely.

Open WebUI says: “The browser is the right interface. You just shouldn’t rent it from OpenAI.”

OpenClaw says: “The browser isn’t the right interface at all.”

That’s a much bolder claim. And honestly, when you think about how people actually interact with technology throughout the day, it makes sense. You’re not sitting in front of a browser all day. You’re in WhatsApp with your family and friends, in Slack with your org, in Telegram with your communities. The browser tab is where you go when you have a dedicated task. Messaging is where you live.

An AI assistant that lives in your messaging layer can do things a browser tab can’t. It can remind you about something at 3pm without you opening an app. It can respond in a group chat where multiple people are coordinating. It can wake up on a schedule and check something for you. It’s persistent in a way that a browser session never is.

What it can actually do
#

The capability surface is broader than “AI in WhatsApp.” Five things matter.

It lives where you are. WhatsApp, Telegram, Slack, Discord, Google Chat, Signal, iMessage. You message it like you’d message a person. It responds in the same channel. It works across devices because the Gateway is always running.

It can switch models on the fly. The docs list 35+ providers: Anthropic, OpenAI, Google, OpenRouter, Ollama, vLLM, and any OpenAI-compatible or Anthropic-compatible endpoint. You can route different conversations to different models. Need a quick answer? Local model. Need deep reasoning? Claude. Same conversation thread, different backends.

It can do things, not just answer questions. The tool inventory includes command execution, browser automation, web search, image and PDF handling, cron jobs, and device node controls. The distinction between cron jobs and heartbeat turns is important: it can both run scheduled tasks and periodically wake itself up to surface something relevant. This isn’t autocomplete. This is an agent with hands.

It remembers. Memory is Markdown files in the workspace. Daily logs in memory/YYYY-MM-DD.md, curated long-term memory in MEMORY.md, exposed through memory_search and memory_get. Sessions can be isolated per agent, workspace, peer, or channel. The fact that memory is plain files you can inspect and edit is philosophically consistent with the local-first story and way more transparent than the hidden memory layers in ChatGPT or Claude.

It can extend itself. ClawHub is the public skill registry. Skills are instruction bundles built around SKILL.md files, while tools are typed capabilities the agent gets to use. Discover, install, publish, version, update. The extension model feels like package management for agent capabilities.

How people actually use it
#

The official showcase clusters around patterns that tell you exactly what OpenClaw is good for.

Browser automation without APIs. PR review feedback delivered in Telegram. School meal and grocery ordering. Accounting intake from emailed PDFs. Slack auto-support. Infrastructure and deployment work. Health assistants. 3D printer and home automation. Voice bridges. One person built and shipped an iOS app from Telegram.

The center of gravity is not generic Q&A. It’s persistent coordination across personal and work systems.

Independent anecdotes on Hacker News point the same direction. One user described using OpenClaw to recover and rebuild a media server, diagnose drive failure, and migrate 1.5TB of data. Another said it became a useful participant in a group chat, tracking personalities and helping the group plan together. These are anecdotes, not benchmarks. But they align: the real appeal is infrastructure, automation, and ongoing conversational context.

The hard truth about running it
#

Here’s where I need to be honest, because the community is tired of puff pieces about OpenClaw and so am I.

Setup is real work. Node, API keys, permissions, channel configurations, operational judgment. This is not “download an app and start chatting.” It’s closer to setting up a production service. The people who love OpenClaw are comfortable with that. The people who bounce off it were expecting something simpler.

Local-only is possible but expensive. The docs are unusually blunt about this. OpenClaw expects large context windows and strong prompt-injection resistance. It recommends the strongest latest-generation model available. Serious local setups may require hardware on the level of multiple maxed-out Mac Studios or equivalent GPU rigs. That’s a big reality check against the “runs privately on my old laptop” narrative.

Token costs can surprise you. Users report it’s easy to accidentally create expensive workflows, especially with naive model defaults. An always-on assistant that wakes up on schedules and processes conversations across multiple channels burns tokens constantly. Without cost controls, your monthly bill can go places you didn’t expect.

The security model is honest but limited. The supported posture is one trusted operator boundary per gateway. This is not hostile multi-tenant isolation. OpenClaw ships a security audit CLI, publishes a MITRE ATLAS-based threat model with 37 identified threats (6 critical), and added VirusTotal scanning for published skills. A high-severity CVE was patched in February 2026. The project is actively fixing real vulnerabilities, which is a good sign. But the docs are explicit that none of this makes the system “secure in all respects.”

Skills are code running in your agent’s context. This is the deepest concern. Skills have access to tools and data. The project’s own security documentation explicitly lists risks: exfiltration, unauthorized commands, sending messages on your behalf, downloading external payloads. You are not installing a chatbot. You are delegating action to an always-on agent with real permissions. Treat it accordingly.

Who’s behind it
#

Peter Steinberger is the creator. The project credits Mario Zechner as the creator of Pi (the underlying agent framework) and names several core contributors. It’s MIT licensed.

There’s an interesting governance story here. Steinberger’s blog says he joined OpenAI on February 14, 2026, and that OpenClaw would move to a foundation while remaining open and independent. I found the announcement but not enough public material to treat the foundation transition as fully completed. Worth watching.

The naming history is also telling. The project went through multiple names. Anthropic asked them to reconsider the earlier “Clawd” branding. It went through “Moltbot” before landing on “OpenClaw.” That chaotic evolution says something about how fast this space moves and how young the project still is, despite its star count.

How it compares to the incumbents
#

Versus ChatGPT. ChatGPT gives you a polished hosted product with Projects, scheduled Tasks, and MCP-based custom apps. OpenClaw gives you self-hosting, provider neutrality, and an assistant that lives in your own messaging channels instead of OpenAI’s browser product. ChatGPT wins on zero-ops convenience. OpenClaw wins on control and communication surface.

Versus Claude. Claude now bundles Projects, Artifacts, Research, and Skills inside Anthropic’s managed environment. That makes it the best native Claude experience. OpenClaw is interesting when you want Claude-level intelligence inside your own channels and control plane rather than inside Anthropic’s product. Different layer, different bet.

Versus Gemini. Gemini’s advantage is ecosystem gravity. Deep Research across Search, Gmail, Drive, NotebookLM. OpenClaw’s advantage is ecosystem neutrality. It sits above many providers and your own devices instead of locking the assistant layer to Google.

How it compares to open-source alternatives
#

OpenClaw spans two categories that are usually separate, which makes direct comparisons tricky.

Open WebUI and LibreChat are stronger as self-hosted browser-based AI workspaces. They unify providers, support agents and MCP, and feel like replacements for the mainstream chat products. OpenClaw’s bet is different: move the assistant out of the browser entirely and into your messaging stack, with an always-on gateway and device nodes.

n8n sits on the other flank as an automation platform. Stronger for deterministic workflows, visual orchestration, and integration breadth. OpenClaw is stronger when you want a persistent assistant you can casually message, with memory, channel presence, and agent-like coordination. n8n automates flows. OpenClaw tries to become the thing you talk to.

What this means
#

The broader pattern is the same one I see across AI tooling right now. The model layer is commoditizing. The interface layer is where the real fight happens. And the interface layer is splitting into at least three bets:

Vendor-hosted SaaS (ChatGPT, Claude, Gemini). Maximum convenience, minimum control. The default for most teams today.

Self-hosted browser workspaces (Open WebUI, LibreChat). Same browser paradigm, but you own it. The infrastructure play.

Communication-layer agents (OpenClaw). Not a workspace at all. An assistant that lives where you already are. The most radical bet.

OpenClaw is the most ambitious of the three. It’s also the highest-maintenance, the highest-risk, and the one that requires the most trust. You’re not just self-hosting a UI. You’re running an always-on agent with real permissions inside your real communication channels.

For power users and tinkerers who are comfortable with that, OpenClaw is one of the most interesting projects in the AI space right now. For everyone else, it’s worth understanding as a signal of where AI assistants are heading. Even if you never install it, the question it raises is the right one: why does your AI assistant live in a browser tab when you don’t?

Running personal AI agents? Tried OpenClaw or something similar? I’d love to hear your setup. Find me on X or Telegram.

Open WebUI Isn't a ChatGPT Clone. It's AI Infrastructure.

Wed, 18 Mar 2026 10:00:00 +0200

Here’s a question nobody’s asking: who owns the layer between your engineers and the AI models they use every day?

Right now, for most teams, the answer is OpenAI. Or Anthropic. Or Google. Your engineers open ChatGPT, or Claude, or Gemini, and they work inside someone else’s product. Someone else’s UI. Someone else’s data policies. Someone else’s feature roadmap.

That’s fine when AI is a nice-to-have. It stops being fine when AI becomes how your team actually works.

Open WebUI is the project that makes this question real. Not because it’s a better chatbot. Because it turns the AI interface layer into infrastructure you can own, deploy, and control. And once you understand what that means, the conversation about AI tooling changes completely.

What Open WebUI actually is
#

Strip away the GitHub stars (128k+ and counting) and the marketing language about “bringing intelligence home.” What you’re looking at is a self-hosted control plane for AI models.

It runs in a container. Docker, Kubernetes, Podman, Helm, whatever your infra looks like. First account becomes admin. Later signups need approval. For a solo setup you can disable login entirely. One container, local storage, browser UI. You’re up and running.

But the interesting design decision is that it’s protocol-first, not vendor-first. Open WebUI uses OpenAI Chat Completions as the shared language across providers. It has compatibility layers for Anthropic. It supports Ollama for local models. It can route to any OpenAI-compatible backend. That makes it less like “an Ollama UI” and more like an operations layer sitting above whatever models you choose to run.

This is the same architectural pattern we’ve seen play out in infrastructure before. Think about how Terraform became the control plane above cloud providers, or how Kubernetes became the orchestration layer above compute. Open WebUI is making that same move for the AI interface layer.

What it can actually do (beyond chat)
#

Most people discover Open WebUI because they want a local ChatGPT. Then they realize the feature surface is much wider than they expected.

RAG and knowledge work. Multiple vector databases, document uploads, URL ingestion, web search across 15+ providers, and full-page URL fetching. This isn’t a toy retrieval setup. It’s a real knowledge pipeline.

Agent capabilities. Open WebUI distinguishes between Tools, Functions, and Pipelines. It supports MCP natively. It can attach external actions like search, scraping, image generation, and voice. It can expose MCP through OpenAPI-compatible flows. This is an agent platform, not just a chat box.

Code execution. Python through Pyodide or Jupyter, Mermaid rendering, interactive artifacts. At the extreme end there’s Open Terminal, which gives the model a real OS-level environment in a container. That’s powerful and terrifying in equal measure.

Team workflows. Folders, projects, chat history, shared conversations, channels for multi-user collaboration, RBAC, SCIM provisioning, OpenTelemetry. The admin surface is deeper than most people expect from an open-source project.

Media and voice. Image generation and editing, speech-to-text and text-to-speech with local, browser, and remote options.

The feature list is impressive. But feature lists are easy. The real question is what happens when you actually run it.

The reality of running it in production
#

For a hobbyist or solo developer, Open WebUI is deceptively simple. Container up, connect a model, start chatting.

For production, the defaults are just defaults. Out of the box you get SQLite, embedded ChromaDB, and one Uvicorn worker. That’s fine for one person. The moment you want multi-worker or multi-node deployment, the project tells you to move to PostgreSQL with PGVector, Redis for caching, and shared storage. Easy to start. Not magically “no-ops” once it matters.

If you use RAG heavily, the reality gets sharper. The project’s own scaling guide warns that the default PDF extractor and default embedding path are common causes of memory leaks and RAM blowups at scale. They explicitly recommend externalizing them in production.

I’m not saying this to dismiss the project. I’m saying it because this is exactly the kind of detail that separates “I read the feature list” from “I actually deployed it.” If you’re considering Open WebUI for your team, go in with eyes open. This is infrastructure. Infrastructure requires ops.

Who’s behind it and why that matters
#

Open WebUI is led by founder Tim J. Baek and backed by Open WebUI, Inc. The team page credits community contributors, but the organization is explicit that it’s not looking for outside governance advice. This is founder-led open source, not a neutral foundation-governed commons.

Why does that matter? Because the business model is visible in the decisions.

Since version 0.6.6, the project added a branding-protection clause for larger deployments. Code up to v0.6.5 remains under the original BSD-3 terms. Enterprise offerings include theming, SLAs, LTS, and direct support. This is the standard playbook: open core with enterprise upsell.

The community has opinions about this. Some people on Hacker News get sharp about the licensing change and the fact that a project called “Open” WebUI has branding restrictions. Others say they don’t care because they’re not planning to fork it anyway.

My take: this is a normal and healthy tension. Building sustainable open-source software costs money. Branding protection is one of the less invasive ways to fund it. But if you’re betting your team’s AI infrastructure on this project, you should understand the governance model you’re buying into.

The security conversation nobody wants to have
#

Here’s the uncomfortable part.

Open WebUI’s Tools, Functions, Filters, Pipes, and Pipelines execute arbitrary Python on your server. The docs say “only install from trusted sources.” That’s honest, but it also means the extension system is a real attack surface.

This isn’t theoretical. A code-injection issue in Direct Connections was patched in 0.6.35. An SSRF issue in retrieval processing was patched in 0.6.37. Both are the kind of vulnerabilities that come with running user-extensible systems.

For your team, this means treating Open WebUI the same way you’d treat any infrastructure component: pin versions, review extensions, monitor for CVEs, control who can install what. The freedom to extend the platform comes with the responsibility to secure it.

Why teams and orgs actually adopt this
#

Features are nice. But nobody migrates their AI tooling because of a feature checklist. They do it because something about the current setup is broken. I spent time researching the best tools for an internal ChatGPT alternative, talking to other engineering leaders who did the same. Here’s what actually drives the decision.

Cost visibility and control. When your team uses ChatGPT or Claude directly, every person needs a subscription. Or worse, everyone shares credentials. Or worst of all, engineers use their personal accounts and company data flows through consumer products with consumer privacy terms. With Open WebUI in front of your API keys, you get one set of credentials, usage tracking per user, and the ability to route different workloads to different models based on cost. Need a quick answer? Route to a cheap local model. Need deep reasoning? Route to Claude or GPT. Same interface, conscious cost allocation.

Data stays where you decide. For a lot of orgs this is the whole conversation. Regulated industries, government contracts, security-conscious startups. The moment your engineers paste proprietary code into ChatGPT, you have a data governance problem. Self-hosting the interface layer means the data flows through your infrastructure, your logging, your retention policies. You can run sensitive workloads on local models that never leave your network, and routine tasks on cloud APIs. Same UI for both.

No vendor lock-in on the workflow layer. This is the one that hits engineering leaders hardest. Today your team builds workflows, prompt libraries, knowledge bases, and habits around ChatGPT. Tomorrow OpenAI changes the pricing, kills a feature, or deprecates a model. Everything you built around their interface is tied to their decisions. When the interface is yours, the models are pluggable. You can switch from GPT to Claude to Gemini to a local model without retraining your team or rebuilding your workflows.

Unified AI experience across the org. Instead of some engineers using ChatGPT, some using Claude, some using local models, and nobody sharing anything, everyone works through one interface. Shared conversations, shared knowledge bases, shared tools. New team member joins, gets access to the same AI setup as everyone else. That might sound like a small thing until you’ve managed an engineering org where every person has their own disconnected AI workflow and none of that institutional knowledge is captured anywhere.

A real sandbox for innovation. Want to test a new model? Add it as a backend. Want to build a custom agent for your team? Use the extension system. Want to integrate your internal knowledge base? Plug in RAG. Want to give your AI access to your tools via MCP? It’s supported. You don’t need to wait for OpenAI or Anthropic to ship a feature. If you can build it, you can plug it in. For teams that move fast, that’s the difference between waiting for a vendor’s roadmap and building what you need right now.

None of this is free. You trade managed simplicity for operational responsibility. But for teams that are serious about AI being part of how they work, not just a tool they occasionally open, owning the interface layer starts making a lot of sense.

How it compares to the incumbents
#

The comparison isn’t really about features. It’s about what you’re optimizing for.

Versus ChatGPT. ChatGPT has Projects, Deep Research, Apps, Company Knowledge, and mature business controls. SSO, retention policies, permissions, training defaults. It’s zero-ops SaaS. Open WebUI’s advantage is that you own the stack. Data stays local. You mix local and remote models. You’re not locked to one vendor’s interface. If zero-ops matters most, ChatGPT wins. If ownership matters most, Open WebUI wins.

Versus Claude. Claude has Artifacts, Projects, Skills, Research, and Google Workspace integration. Anthropic also created MCP. Open WebUI can route to Claude’s models, but Anthropic’s own docs note that their OpenAI-compatible endpoint is mainly for testing, and the native API is recommended for the full feature set including PDF processing, citations, extended thinking, and prompt caching. Protocol compatibility is powerful, but it flattens vendor-specific superpowers.

Versus Gemini. Gemini is strongest when your work already lives in Google’s ecosystem. Deep Research can pull from Search, Gmail, Drive, and NotebookLM. Open WebUI is the better fit if you want one interface above Google models, Anthropic models, OpenAI models, local models, and whatever comes next.

The pattern is consistent: the SaaS products win on managed experience and vendor-native depth. Open WebUI wins on control and independence. Neither is wrong. They’re different bets.

How it compares to open-source alternatives
#

The open-source landscape is more nuanced.

LibreChat is probably the closest direct competitor. Agents, MCP, artifacts, code interpreter, broad provider support. It reads like the closest open-source answer to the mainstream chat products. Open WebUI feels more infrastructure-oriented, more invested in deployment patterns, admin controls, and the local/offline story.

AnythingLLM leads with “chat with your docs.” Built-in agents, multi-user support, vector databases, document pipelines, no-code agent builder. If your center of gravity is private documents and internal knowledge workflows, AnythingLLM has a clear story. Open WebUI is broader if you want one extensible front end for many kinds of AI workflows.

Onyx is enterprise-search-heavy. Connectors, synced knowledge sources, deep research, MCP, enterprise knowledge grounding. Compelling when “AI over company knowledge” is the main requirement. Open WebUI is a general AI workspace. Onyx is sharper as an enterprise retrieval layer.

Jan is desktop-first and personal. 100% offline, runs on your laptop, turns it into an AI workstation. Great for single-user local AI. Open WebUI becomes more compelling the moment you want browser access, shared workspaces, or team deployment.

What this actually means for engineering leaders
#

Here’s the strategic point that matters more than any feature comparison.

For the last two years, the AI interface layer has been bundled with the model provider. You use ChatGPT because you want GPT. You use Claude because you want Anthropic’s models. The interface and the intelligence came as a package deal.

Open WebUI (and projects like it) are unbundling that. The model is one layer. The interface is another. And once those layers separate, the dynamics change.

Your team can switch models without switching workflows. You can run sensitive workloads on local models and routine work on cloud APIs, through the same interface. You can add RAG, agents, and custom tools without waiting for OpenAI to ship them. You can audit, log, and control every interaction.

The price of that freedom is real. You own deployment. You own patching. You own extension security. You own operational tuning. You inherit everything that SaaS normally hides behind a login page.

That’s not a reason to avoid it. It’s a reason to approach it the way you’d approach any infrastructure decision: with clear requirements, honest assessment of your ops capacity, and a plan for what happens when things break at 3am.

Who should care about this
#

If you’re a solo developer who wants a better local AI setup, Open WebUI is probably the best option out there right now. Install it, connect your models, enjoy.

If you’re an engineering leader evaluating AI tooling for your team, Open WebUI is worth understanding even if you don’t deploy it. It represents where the AI tooling ecosystem is heading: model-agnostic interfaces, self-hosted control planes, protocol-first architectures. The question isn’t whether this pattern wins. It’s how fast.

If you’re already running AI agents in production (like I am), Open WebUI is interesting as the potential front end for your entire AI operations layer. One interface for your agents, your knowledge base, your model routing, your team’s AI workflows. That’s a compelling vision. Whether the project can deliver on it at enterprise scale is still an open question.

Either way, the conversation has shifted. It’s no longer just about which model is best. It’s about who controls the layer where your team meets the model. Open WebUI is one of the first projects to take that question seriously.

And that’s worth paying attention to.

Running self-hosted AI infrastructure? Thinking about owning the interface layer? I’d love to hear what you’re using. Find me on X or Telegram.

Your AI Agents Are Flying Blind. Here's How to Fix That.

Sun, 15 Mar 2026 10:00:00 +0200

Your AI agent just rewrote the authentication flow. The code is clean. Tests pass. The PR looks great.

One problem: it broke the SSO integration with three enterprise customers because it didn’t know the auth service has a contract with the identity provider that requires a specific token format. That contract lives in a Slack thread from 2023 and one engineer’s head.

The agent didn’t make a mistake. It made a perfectly reasonable decision with the information it had. The information it had was almost nothing.

This is happening across your codebase right now. Not just with authentication. With everything. Business rules, API contracts, deployment constraints, database conventions, service boundaries. Your agents write code that compiles, passes tests, and violates assumptions that live nowhere except in people’s heads and scattered documents nobody maintains.

I’ve written about why context is the fundamental problem in AI. I’ve written about putting AI agents on the org chart and managing them like team members. But none of that matters if the agents start every session blind.

If you’re running agents in production, this is the problem you need to solve next.

Two teams, same agents, wildly different results
#

Let me describe what I’m seeing.

Team A has agents embedded in their development workflow. An agent picks up a ticket to add a new validation rule to the user registration flow. Before writing a line of code, it queries a knowledge base and gets back: the existing validation rules, the reason the email format check is stricter than RFC 5322 (because of a legacy migration), the API contract with the notification service, and the team’s convention for error handling. The agent writes code that fits. The PR gets approved on the first review.

Team B has the exact same agents, same models, same IDE. Their agent picks up a similar ticket. It reads the code in the repo, sees patterns, generates a solution. The solution uses a different error handling pattern than the rest of the codebase. It changes the validation response format, which breaks the mobile client. It adds a database column without following the team’s migration conventions. The PR gets three rounds of review comments and a refactor.

Same AI. Same capability. Completely different outcomes.

The difference isn’t the model. It’s that Team A solved the knowledge problem and Team B didn’t.

Where knowledge actually lives (and why that’s broken)
#

In most engineering organizations, critical knowledge is scattered across:

People’s heads. The worst possible storage medium.
Slack threads. Searchable in theory, buried in practice.
Confluence pages. Written once, updated never.
Code comments. Spotty at best, misleading at worst.
Tribal knowledge. “Ask Daniel, he built that service.”

None of this is accessible to AI agents. None of it is structured for retrieval. None of it stays current.

And here’s the compounding problem: as AI agents do more work, the knowledge gap matters more, not less. When humans wrote all the code, at least the person writing it carried the context. When agents write the code, the context has to come from somewhere else. Or it doesn’t come at all.

Think about it this way: a senior developer who’s been on your team for three years carries hundreds of micro-decisions in their head. Why the payment service retries exactly three times. Why the user permissions check happens at the API gateway, not the service layer. Why that database query uses a specific index hint. Now imagine replacing that developer with an agent that knows none of this. That’s what you’re doing every time an agent starts a session.

The wrong way to fix this
#

The instinct is to throw more code at the agent. Bigger context windows. More files in the prompt. RAG over the entire codebase.

I’ve seen teams try this. Here’s what happens:

They dump the entire repo into the context. The agent drowns in irrelevant code and can’t find the signal, and every token costs money, so you’re paying premium rates to confuse your own agents. They build RAG over Confluence. The retrieval returns pages from 2021 that contradict how things actually work. They write massive README files. Nobody maintains them. Within three months they’re more misleading than helpful.

And the costs compound. More tokens in the context means higher API bills on every single request. Bad context leads to wrong code, which leads to longer review cycles, which leads to rework, which means more agent sessions with the same bad context. It’s compound interest working against you. Every layer of waste multiplies the next.

The problem isn’t volume of information. It’s the right information, maintained, structured, and delivered at the moment the agent needs it. Get this wrong and you’re not just getting bad code. You’re paying more for it with every iteration.

What actually works: a developer knowledge hub
#

After months of thinking about this problem and looking at how every available solution falls short, I believe the answer is a system with three components that work together.

Layer 1

Source of Truth

📁

Knowledge Repo (Git)
Developers author markdown: product rules, system docs, architecture specs, skills

▼ CI/CD syncs on every merge ▼

Layer 2

Index & Push

🔍

Vector Store + Embeddings
Chunk, embed, index → semantic search

📄

AGENTS.md + Skills per repo
Generated context + reusable workflows

▼ Serves queries at dev time ▼

Layer 3

Universal Bridge

🔌

MCP Server
One server → every IDE & agent can query knowledge

▼

Consumers

All tools

💻

Cursor Claude Code Copilot Codex Kiro + any future MCP-compatible tool

Git for authoring
#

Not Confluence. Not Notion. Not some SaaS product with its own editing UI.

A Git repository. Markdown files. Pull requests for review. CI/CD for automation. The same workflow developers already use for code.

Why Git? Because the adoption problem kills every knowledge initiative that requires developers to learn a different tool. PRs already have review workflows. Blame shows who wrote what. History shows when things changed. CODEOWNERS controls who can approve what. Your developers already know all of this. Zero adoption friction.

The repo holds four types of knowledge:

Product knowledge. Business rules, domain logic, edge cases, validation requirements. Why the user registration flow requires that specific email format. Why the discount calculation has a different rounding rule for enterprise customers. This changes every sprint.

System knowledge. Build commands, repo structure, coding conventions, database patterns, module boundaries. Why you always run migrations before the test suite. Why the cache invalidation uses event sourcing instead of TTL. This changes when code changes.

Architecture knowledge. API contracts, data flows, service boundaries, system invariants. Why the payment service is the only service allowed to write to the transactions table. Why the notification queue has exactly-once delivery semantics. This changes rarely but matters enormously.

Operational skills. Code review checklists, debugging guides, feature scaffolding patterns, cross-repo change workflows. How to add a new API endpoint. How to set up a feature flag. How to run a database migration across services. How the CI/CD pipeline works, which checks run on PR, which run on merge, what gates production. How linting and formatting are enforced and what to do when a check fails. How to roll back a deployment. How to triage a failing build. These are reusable agent workflows that encode how your team actually works. Not just the code, but the entire delivery process around it.

One thing you’ll notice is missing from this list: the code itself. That’s intentional. AI IDEs and coding agents like Cursor, Copilot, and Claude Code already do a solid job indexing your codebase. They understand file structure, imports, function signatures. You don’t need to duplicate that work. What they can’t index is everything around the code. The why, the rules, the decisions. That’s what the knowledge hub is for. That said, the system is designed to be agile. If you want to add code indexing, documentation from other sources, or any other category of data, the architecture supports it. Same Git authoring, same search layer, same MCP delivery.

Semantic search for retrieval
#

Raw markdown is great for humans. Useless for agents that need to find the right three paragraphs out of thousands for a specific task.

This layer chunks the markdown by section, embeds it into vectors, and indexes it for semantic retrieval. When an agent asks “what are the validation rules for the registration flow?” it gets the relevant sections, with citations back to the source documents.

AWS Bedrock Knowledge Bases does this out of the box. So does Pinecone, Weaviate, or any vector store with a decent chunking strategy. The specific tool doesn’t matter. What matters is that knowledge becomes semantically searchable, not just keyword-matchable.

CI/CD syncs markdown to the search index on every merge. Knowledge stays current automatically. No manual re-indexing. No stale embeddings.

MCP for delivery
#

Here’s where it comes together.

Your developers use Cursor, Claude Code, Copilot, Codex, Kiro. Probably several of them. Each one is an island. Each one starts every session without context.

Model Context Protocol (MCP) is the open standard that connects all of them. I wrote a deep dive on MCP earlier. If you haven’t read it, start there.

One MCP server wraps your knowledge base and exposes it to every IDE and agent through a standard interface. Build one server. Every tool connects natively. New tools that support MCP work automatically. Zero per-tool maintenance.

The server exposes three tools: search_knowledge for semantic search across all knowledge, get_document to fetch a specific doc by path, and list_knowledge_bases to discover available sources. Simple interface, massive impact.

Without MCP: You build a separate integration for each IDE. Maintain six connectors. Each tool gets knowledge differently. Every new tool means new work.

With MCP: You build one server. Everything connects. When the next AI coding tool launches next month, it just works.

The loop that makes it compound
#

Here’s where this gets really powerful. The system doesn’t just serve knowledge. It grows.

🔍

Read

Agent queries KB
via MCP

→

💻

Work

Develops with
full context

→

📝

Write Back

Opens PR to
knowledge repo

→

✅

Merge

Dev reviews
CI re-indexes

↩

🔄

Updated

Next session
starts smarter

Fully automated. No manual curation. Knowledge grows as the team develops.

The workflow in detail:

Agent reads. Before starting work, queries the knowledge base via MCP. Gets business rules, conventions, architecture constraints relevant to the task.
Agent works. Develops with full context. The code actually follows the patterns and rules.
Agent writes back. A built-in skill instructs the agent to capture what it learned during development and open a PR to the knowledge repo.
Developer reviews. Standard PR review. Approves or refines the knowledge doc.
CI syncs. Merged knowledge is automatically indexed. Next agent session starts smarter.

Knowledge capture becomes part of development, not a separate chore. The developer just reviews. No separate authoring step.

There’s a sixth step that takes this even further. When new knowledge merges, a CI step can run an LLM over the diff and ask: “What else in the entire knowledge base might be affected by this change?” Remember, this is a centralized system across all your repos. A change to how one service handles authentication could affect product knowledge for three other services, architecture docs for the API gateway, and operational skills for the deployment pipeline. The system uses embeddings to find related documents across every domain, checks for contradictions or staleness, and opens follow-up issues flagging what might need updating. Ripple effect detection across your entire engineering knowledge. You update the validation rules for user registration, and the system flags that the API contract doc, the mobile client integration guide, and the error handling conventions might all need a second look. It’s cheap to run and catches the kind of cross-cutting knowledge drift that humans miss because nobody has visibility into every document across every team.

Every feature built makes the next feature easier. Every agent session makes the next session smarter. The knowledge compounds.

The AGENTS.md safety net
#

Not every agent session has MCP access. Sometimes developers work offline. Sometimes a new tool doesn’t support MCP yet. Sometimes the knowledge server is down.

For these cases, CI generates a lightweight AGENTS.md in each repo. It’s a table of contents for the agent: what this repo does, how to build and test it, architecture boundaries, conventions and constraints, and where to find the full knowledge base.

Think of it as the offline fallback. Agents get essential context even without network access. Push model (always in-repo) complementing the pull model (on-demand via MCP).

Why nothing on the market solves this
#

I looked at many solutions out there. Each solves a piece, and the approach I’m describing borrows the best parts from all of them.

Meta-repos (centralized Git docs). Git-native authoring, but no semantic search. Agents can’t find what they need.

Wiki + RAG (Confluence/Notion with retrieval). Searchable, but not Git-native. Developers won’t update it. Knowledge rots within months.

Code wikis (auto-generated from code). Clever, but usually tied to one AI tool. Not universal.

Cloud RAG services (Bedrock KB, Vertex). Managed search, but no authoring story. Where does the content come from?

Agent memory (Copilot memory, Letta). Per-tool, per-session. Not centralized. Not shared across the team.

You need all five capabilities in one system. That’s what this approach delivers.

How to start (without boiling the ocean)
#

Day 1: Create the knowledge repo. Sit with your two or three most senior engineers, the ones who carry the most context in their heads. Ask them: “What do you find yourself explaining over and over?” That’s your first knowledge document.

Day 2-3: Set up semantic search. Connect your markdown to a vector store. Get retrieval working. This is not a multi-week project. The tooling exists. Use it.

Day 4-5: Deploy the MCP server. Configure it in your team’s primary IDE. Have a developer pair with an agent on a real task and compare the output to what they’d get without the knowledge base. That’s your first signal.

Week 2: Add the write-back loop. Build the skill that instructs agents to capture knowledge after completing work. Train your developers on how to review knowledge PRs, not just code PRs. This is where it starts compounding.

The technology side of this is days of work. The harder part is getting your team to treat knowledge as a first-class deliverable, not an afterthought. That’s a leadership problem, not a tooling problem. But once developers see their agents producing better code because someone took 20 minutes to document business rules, the culture shift happens on its own.

We’re in the AI era. If the infrastructure takes you months, you’re overengineering it. Get something working in days, iterate from there. The humans will make it great.

The key insight: start with the knowledge that hurts most when it’s missing. That’s usually the domain logic, the business rules that experienced developers carry in their heads and that agents get wrong in ways that look correct until they hit production.

The uncomfortable question
#

If your AI agents are generating code without context, how much of that code is actually correct?

Not “does it compile” correct. Not “does it pass the tests you wrote” correct. Actually correct. Follows the business rules, respects the architecture, uses the conventions, handles the edge cases that burned you last quarter.

If you can’t answer that confidently, your agents aren’t helping as much as you think. They’re generating plausible-looking code that somebody has to review against all the unwritten knowledge that exists only in people’s heads. And you’re paying for every token of that wrong output, then paying again for the review, again for the rework, and again when the agent generates the same mistake tomorrow because nothing changed.

That’s not an AI problem. That’s a knowledge management problem. And it’s solvable.

The organizations that figure this out first will have AI agents that don’t just write code. They write the right code. Every time. From session one.

That’s the difference between AI as a novelty and AI as a genuine multiplier. And it’s what separates teams that are actually shipping with agents from teams that are just generating code and hoping for the best.

Building knowledge systems for AI agents? Thinking about MCP? I’d love to hear how you’re approaching it. Find me on X or Telegram.

Ship Faster Without Breaking Things: DORA 2025 in Real Life

Sat, 04 Oct 2025 00:00:00 +0000

Last year, teams using AI shipped slower and broke more things. This year, they’re shipping faster, but they’re still breaking things. The difference between those outcomes isn’t the AI tool you picked—it’s what you built around it.

The 2025 DORA State of AI-assisted Software Development Report introduces an AI Capabilities Model based on interviews, expert input, and survey data from thousands of teams. Seven organizational capabilities consistently determine whether AI amplifies your effectiveness or just amplifies your problems.

This isn’t about whether to use AI. It’s about how to use it without making everything worse.

First, what DORA actually measures
#

DORA is a long-running research program studying how software teams ship and run software. It measures outcomes across multiple dimensions:

Organizational performance – business-level impact
Delivery throughput – how fast features ship
Delivery instability – how often things break
Team performance – collaboration and effectiveness
Product performance – user-facing quality
Code quality – maintainability and technical debt
Friction – blockers and waste in the development process
Burnout – team health and sustainability
Valuable work – time spent on meaningful tasks
Individual effectiveness – personal productivity

These aren’t vanity metrics. They’re the lenses DORA uses to determine whether practices help or hurt.

What changed in 2025
#

Last year: AI use correlated with slower delivery and more instability.

This year: Throughput ticks up while instability still hangs around.

In short, teams are getting faster. The bumps haven’t disappeared. Environment and habits matter a lot.

The big idea: capabilities beat tools
#

DORA’s 2025 research introduces an AI Capabilities Model. Seven organizational capabilities consistently amplify the upside from AI while mitigating the risks:

Clear and communicated AI stance – everyone knows the policy
Healthy data ecosystems – clean, accessible, well-managed data
AI-accessible internal data – tools can see your context safely
Strong version control practices – commit often, rollback fluently
Working in small batches – fewer lines, fewer changes, shorter tasks
User-centric focus – outcomes trump output
Quality internal platforms – golden paths and secure defaults

These aren’t theoretical. They’re patterns that emerged from real teams shipping real software with AI in the loop.

Below are the parts you can apply on Monday morning.

1. Write down your AI stance
#

Teams perform better when the policy is clear, visible, and encourages thoughtful experimentation. A clear stance improves individual effectiveness, reduces friction, and even lifts organizational performance.

Many developers still report policy confusion, which leads to underuse or risky workarounds. Fixing clarity pays back quickly.

Leader move
#

Publish the allowed tools and uses, where data can and cannot go, and who to ask when something is unclear. Then socialize it in the places people actually read—not just a wiki page nobody visits.

Make it a short document:

What’s allowed: Which AI tools are approved for what use cases
What’s not allowed: Where the boundaries are and why
Where data can go: Which contexts are safe for which types of information
Who to ask: A real person or channel for edge cases

Post it in Slack, email it, put it in onboarding. Make not knowing harder than knowing.

2. Give AI your company context
#

The single biggest multiplier is letting AI use your internal data in a safe way. When tools can see the right repos, docs, tickets, and decision logs, individual effectiveness and code quality improve dramatically.

Licenses alone don’t cut it. Wiring matters.

Developer move
#

Include relevant snippets from internal docs or tickets in your prompts when policy allows. Ask for refactoring that matches your codebase, not generic patterns.

Instead of:

Write a function to validate user input

Try:

Write a validation function that matches our pattern in
docs/validators/base.md. It should use the same error
handling structure we use elsewhere and return ValidationResult.

Context makes the difference between generic code and code that fits.

Leader move
#

Prioritize the plumbing. Improve data quality and access, then connect AI tools to approved internal sources. Treat this like a platform feature, not a side quest.

This means:

Audit your data: What’s scattered? What’s duplicated? What’s wrong?
Make it accessible: Can tools reach the right information safely?
Build integrations: Connect approved AI tools to your repos, docs, and systems
Measure impact: Track whether context improves code quality and reduces rework

This is infrastructure work. It’s not glamorous. It pays off massively.

3. Make version control your safety net
#

Two simple habits change the payoff curve:

Commit more often
Be fluent with rollback and revert

Frequent commits amplify AI’s positive effect on individual effectiveness. Frequent rollbacks amplify AI’s effect on team performance. That safety net lowers fear and keeps speed sane.

Developer move
#

Keep PRs small, practice fast reverts, and do review passes that focus on risk hot spots. Larger AI-generated diffs are harder to review, so small batches matter even more.

Make this your default workflow:

Commit after every meaningful change, not just when you’re “done”
Know your rollback commands by heart: git revert, git reset, git checkout
Break big AI-generated changes into reviewable chunks before opening a PR
Flag risky sections explicitly in PR descriptions

When AI suggests a 300-line refactor, don’t merge it as one commit. Break it into logical pieces you can review and revert independently.

4. Work in smaller batches
#

Small batches correlate with better product performance for AI-assisted teams. They turn AI’s neutral effect on friction into a reduction. You might feel a smaller bump in personal effectiveness, which is fine—outcomes beat output.

Team move
#

Make “fewer lines per change, fewer changes per release, shorter tasks” your default.

Concretely:

Set a soft limit on PR size (150-200 lines max)
Break features into smaller increments that ship value
Deploy more frequently, even if each deploy does less
Measure cycle time from commit to production, not just individual velocity

Small batches reduce review burden, lower deployment risk, and make rollbacks less scary. When AI is writing code, this discipline matters more, not less.

5. Keep the user in the room
#

User-centric focus is a strong moderator. With it, AI maps to better team performance. Without it, you move quickly in the wrong direction.

Speed without direction is just thrashing.

Leader move
#

Tie AI usage to user outcomes in planning and review. Ask how a suggestion helps a user goal before you celebrate a speedup.

In practice:

Start feature discussions with the user problem, not the implementation
When reviewing AI-generated code, ask “Does this serve the user need?”
Measure user-facing outcomes (performance, success rates, satisfaction) alongside velocity
Reject optimizations that don’t trace back to user value

AI is good at generating code. It’s terrible at understanding what your users actually need. Keep humans in the loop for that judgment.

6. Invest in platform quality
#

Quality internal platforms amplify AI’s positive effect on organizational performance. They also raise friction a bit, likely because guardrails block unsafe patterns.

That’s not necessarily bad. That’s governance doing its job.

Leader move
#

Treat the platform as a product. Focus on golden paths, paved roads, and secure defaults. Measure adoption and developer satisfaction.

What this looks like:

Golden paths: Make the secure, reliable, approved way also the easiest way
Good defaults: Bake observability, security, and reliability into templates
Clear boundaries: Make it obvious when someone’s about to do something risky
Fast feedback: Catch issues in development, not in production

When AI suggests code, a good platform will catch problems early. It’s the difference between “this breaks in production” and “this won’t even compile without the right config.”

7. Use value stream management so local wins become company wins
#

Without value stream visibility, AI creates local pockets of speed that get swallowed by downstream bottlenecks. With VSM, the impact on organizational performance is dramatically amplified.

If you can’t draw your value stream on a whiteboard, start there.

Leader move
#

Map your value stream from idea to production. Identify bottlenecks. Measure flow time, not just individual productivity.

Questions to answer:

How long does it take an idea to reach users?
Where do handoffs slow things down?
Which stages have the longest wait times?
Is faster coding making a difference at the business layer?

When one team doubles their velocity but deployment still takes three weeks, you haven’t improved the system. You’ve just made the queue longer.

VSM makes the whole system visible. It’s how you turn local improvements into company-level wins.

Quick playbooks
#

For developers
#

Commit smaller, commit more, and know your rollback shortcut.
Add internal context to prompts when allowed. Ask for diffs that match your codebase.
Prefer five tiny PRs over one big one. Your reviewers and your on-call rotation will thank you.
Challenge AI suggestions that don’t trace back to user value. Speed without direction is waste.

For engineering leaders
#

Publish and socialize an AI policy that people can actually find and understand.
Fund the data plumbing so AI can use internal context safely. This is infrastructure work that pays compound returns.
Strengthen the platform. Measure adoption and expect a bit of healthy friction from guardrails.
Run regular value stream reviews so improvements show up at the business layer, not just in the IDE.
Tie AI adoption to outcomes, not just activity. Measure user-facing results alongside velocity.

The takeaway
#

AI is an amplifier. With weak flow and unclear goals, it magnifies the mess. With good safety nets, small batches, user focus, and value stream visibility, it magnifies the good.

The 2025 DORA report is very clear on that point, and it matches what many teams feel day to day: the tool doesn’t determine the outcome. The system around it does.

You can start on Monday. Pick one capability, make it better, measure the result. Then pick the next one.

That’s how you ship faster without breaking things.

Want the full data? Download the complete 2025 DORA State of AI-assisted Software Development Report.

GitHub's Double CLI Release: How Two AI Tools Are Reshaping Development Workflows

Fri, 26 Sep 2025 00:00:00 +0000

This week, GitHub released not one but two different CLI tools for AI development. Most people are focusing on the individual features. I’m seeing something bigger: a significant step toward AI becoming development infrastructure rather than just an assistant.

Here’s what actually happened: GitHub released both an update to their regular CLI (version 2.80.0) and a completely separate standalone Copilot CLI tool. Together, they represent two different but complementary approaches to AI-powered development.

This represents a meaningful shift in how we can build and maintain software.

Two Different Tools, One Big Vision
#

Let me break down what GitHub actually released:

Tool 1: GitHub CLI 2.80.0 with Agent Tasks
#

This updates the regular gh CLI you already know with new agent-task commands:

# Start a coding agent task and track it
gh agent-task create "refactor the authentication flow"

# List all your running tasks 
gh agent-task list

# Watch it work in real-time
gh agent-task view 1234 --log --follow

This solves the “black box” problem I had with the GitHub MCP server. Before, you could trigger the coding agent but had zero visibility into what it was doing. Now you can actually see the work happening and integrate it into scripts.

For the full command reference, see GitHub CLI 2.80.0 release notes.

Tool 2: Standalone Copilot CLI
#

This is completely separate. You install it with npm install -g @github/copilot and it becomes an interactive AI partner in your terminal:

# Interactive mode - have a conversation
$ copilot
> Help me find all the CSV files in this directory recursively
AI suggests: find . -name "*.csv" -type f

# Autonomous mode - one-shot commands 
$ copilot -p "create a Python script to parse log files"
# AI writes the script, asks permission, then creates the file

The Key Difference
#

GitHub CLI agent-tasks = manage long-running coding projects (like delegating work to a team member)

Copilot CLI = interactive terminal assistance (like pair programming with AI)

Here’s where it gets interesting. You can combine both:

# Use Copilot CLI to craft the perfect task description
$ copilot -p "help me write a task description for refactoring our auth system"

# Then delegate it to the coding agent
$ gh agent-task create "$(copilot -p 'write task: refactor auth system')"

# Monitor it while doing other work
$ gh agent-task view $TASK_ID --log --follow

We just went from “AI helps me code” to “AI runs my entire development process.” That’s not an incremental improvement. That’s a category shift.

The Missing Piece: Context-Aware AI That Runs Everywhere
#

To understand why this matters, you have to think about what makes these CLI releases fundamentally different from other AI development tools. It’s not that GitHub suddenly built smarter AI. OpenAI and Anthropic probably have better raw models. What’s different is that GitHub’s AI already knows your codebase.

When you call OpenAI’s API or use Claude directly, you’re starting fresh every time. You have to explain your architecture, your patterns, your naming conventions. You’re basically teaching the AI about your project from scratch with every interaction. It’s powerful, but it’s also exhausting.

GitHub’s coding agent is different because it lives in your repository. It already understands your issues, your pull requests, your workflow patterns. It knows how your team writes code. And now, with CLI access, that context-aware intelligence can work automatically in your production workflows.

Here’s what that means practically: when your monitoring system detects a performance issue, the GitHub coding agent doesn’t just get the error message. It gets your entire codebase context, recent deployments, related issues, and team patterns. When you trigger an agent-task from your CI pipeline, it’s not running generic analysis - it’s applying intelligence that already knows your specific architecture, coding standards, and business logic.

The Model Selection Catch
#

Here’s something important I discovered while testing these tools: you can only choose which AI model to use with the standalone Copilot CLI, not with the agent-task commands.

The agent-task commands are locked to whatever model GitHub has configured for their coding agent - currently Claude 4 Sonnet as of September 2025. There’s no way to switch it to GPT-5 or any other model. The standalone Copilot CLI, on the other hand, lets you pick your model by setting an environment variable before running commands.

This creates an interesting tradeoff. The agent-tasks give you AI that truly understands your specific project context, but you’re stuck with GitHub’s model choice. The standalone CLI lets you choose between Claude or GPT-5, but each conversation starts fresh without deep knowledge of your codebase.

In practice, this means you get context or you get control, but not both. For most workflows, I’d choose context over control - having AI that knows your repository is more valuable than being able to switch models. But for complex reasoning tasks where you need GPT-5’s capabilities, the standalone CLI becomes the better choice.

What the Web Interface Doesn’t Want You to Know
#

If you read GitHub’s official documentation about Copilot coding agent limitations, you’ll see statements like “You cannot change the AI model” and “You cannot integrate with external systems.” Reading this, you’d think these are fundamental technical constraints.

But the CLI releases expose these as design choices, not technical limitations. The agent-task commands let you script everything, monitor progress in real-time, and integrate with any tool that can run shell commands. The standalone Copilot CLI gives you model selection that the web interface deliberately hides.

This reveals something important about how developer tools get designed. When companies build “user-friendly” interfaces, they often hide capabilities to avoid overwhelming users. The problem is that hiding complexity also hides possibility. The web interface trains you to think of AI as a black box you occasionally visit, rather than as programmable infrastructure you can integrate into your workflows.

The CLI approach is different - it makes AI composable. Instead of protecting you from complexity, it gives you the tools to manage complexity. That’s the difference between convenient shortcuts and real automation.

Real Examples: What You Can Build When Both Tools Work Together
#

Once you have both an interactive AI assistant and a way to manage long-running coding tasks, the possibilities get wild. Here are some workflows, from beginner to advanced:

Simple Debug Session (Beginner-Friendly)
#

#!/bin/bash
# Use both tools to debug a failing test

# First, get quick guidance from Copilot CLI
copilot -p "My test is failing with 'connection timeout'. What should I check first?"

# Based on the advice, let the agent investigate and fix
gh agent-task create "Test 'user-login-test' is failing with connection timeout. \
 Check database connection, network config, and timeout settings. \
 Fix any obvious issues you find."

# Monitor the progress
gh agent-task list

Smart Performance Monitoring (Using Both Tools)
#

#!/bin/bash
# When servers get slow, use both AIs to investigate and fix
# Note: Assumes get_cpu_usage() function is defined elsewhere

while true; do
 if [ $(get_cpu_usage) -gt 80 ]; then
 echo "CPU usage high, investigating..."

 # First, use Copilot CLI to quickly analyze what's happening
 ANALYSIS=$(copilot -p "Help me understand what might cause CPU usage of $(get_cpu_usage)% in a web app")

 # Then delegate the actual investigation to the coding agent
 TASK_ID=$(gh agent-task create "CPU is at $(get_cpu_usage)%. \
 Analysis suggests: $ANALYSIS \
 Investigate recent deployments and create a fix." \
 --model gpt-5)

 echo "Created task $TASK_ID to investigate. Monitoring progress..."

 # Watch for completion and take action
 gh agent-task view $TASK_ID --log --follow | \
 grep -i "pull request" | \
 while read pr_line; do
 echo "Performance fix ready: $pr_line"
 notify-team "AI created performance fix: $pr_line"
 done
 fi
 sleep 300
done

Intelligent Code Review Pipeline
#

#!/bin/bash
# Use both tools for comprehensive code reviews

# When a new PR is created (webhook trigger)
PR_NUMBER=$1

# First, get quick insights from Copilot CLI
REVIEW_FOCUS=$(copilot -p "What should I look for when reviewing a PR for $PR_TITLE? Give me 3 key areas to focus on.")

# Then delegate the actual review to the coding agent
gh agent-task create "Review PR #$PR_NUMBER. Focus on: $REVIEW_FOCUS. \
 Look for bugs, security issues, and maintainability problems. \
 Add review comments and create follow-up tasks for any issues." \
 --model gpt-5

Development Workflow Orchestration
#

#!/bin/bash
# Complete development workflow using both tools

# Daily maintenance routine
daily_maintenance() {
 # Use Copilot CLI to plan what needs attention
 PRIORITIES=$(copilot -p "Look at our recent commits and issues. What are the top 3 maintenance tasks I should focus on today?")

 echo "Today's AI-suggested priorities: $PRIORITIES"

 # Create agent tasks for each priority
 echo "$PRIORITIES" | while IFS= read -r task; do
 if [[ -n "$task" ]]; then
 gh agent-task create "$task - make it production ready"
 fi
 done
}

# Smart test generation from failures 
monitor_production_errors() {
 tail -f /var/log/app.log | grep ERROR | while read error; do
 # Quick analysis with Copilot CLI
 TEST_STRATEGY=$(copilot -p "How should I test for this error: '$error'?")

 # Create comprehensive tests with coding agent
 gh agent-task create "Production error: '$error'. \
 Testing strategy: $TEST_STRATEGY \
 Write comprehensive tests to prevent this." \
 --model gpt-5
 done
}

The common pattern here? We’re moving from reactive to proactive. Instead of fixing problems after they happen, we’re building systems that think ahead and improve continuously.

More importantly, we’re combining quick AI assistance with deep AI work. Copilot CLI helps you think through problems fast. The coding agent executes the actual work. Together, they create workflows that are both intelligent and thorough.

The Economics Make Sense for Both Tools
#

Here’s something interesting about the pricing: both tools use your existing Copilot subscription and count against your monthly premium request quota. The specifics matter:

Agent-task commands: Each task counts as one premium request, regardless of complexity:

# These all cost the same: 1 request each
gh agent-task create "fix typo in README"
gh agent-task create "migrate our entire codebase to Python 3.12"
gh agent-task create "do a full security audit and fix everything"

Copilot CLI: Each interaction (prompt) counts as one premium request:

# Each of these is 1 request
copilot -p "help me write a regex"
copilot -p "explain this error and suggest fixes"
copilot -p "create a complete monitoring dashboard"

Important pricing details:

Premium request quotas vary by plan (check GitHub Copilot billing docs)
You’re not charged per API call or line of code generated
Complex tasks cost the same as simple ones within each tool

This pricing model encourages ambitious automation. Don’t ration your AI usage. Don’t optimize for fewer requests. Build the automation you actually want.

Strategic insight: Use Copilot CLI for quick decisions and planning. Use agent-tasks for substantial work. This optimizes your premium request budget.

Important Limitations and Security Considerations
#

While these tools are powerful, they come with important limitations and security considerations:

Security Risks:

Copilot CLI can modify files and execute commands - only use in trusted directories
Always review AI-generated code before running it, especially in production
Agent-task outputs should be reviewed for security vulnerabilities before merging

Current Limitations:

No external integrations yet (tools work within GitHub ecosystem only)
Agent-tasks are repo-bound (no cross-repository context)
Both tools are in preview and may change significantly
Limited to GitHub’s model selection (you can’t use your own AI models)

Responsible Use:

Don’t blindly trust AI outputs - human oversight is essential
Start with non-critical tasks while you learn the tools’ behavior
Monitor your premium request quota to avoid service interruptions
Be mindful of sensitive data in prompts (logs may be retained)

We Just Crossed Multiple Lines We Can’t Uncross
#

Think about how AI coding tools have evolved, and what GitHub just delivered:

Phase 1: Autocomplete (AI suggests the next few characters)
Phase 2: Chat (AI answers questions and helps with tasks)
Phase 3: Interactive partnership (Copilot CLI becomes your terminal buddy)
Phase 4: Autonomous delegation (agent-tasks work independently on projects)

Most companies are still figuring out Phase 2. GitHub just delivered both Phase 3 and 4 at the same time.

That’s not incremental progress. That’s the difference between using AI tools and having AI colleagues.

# Interactive partnership
$ copilot
> I'm getting a weird database error. Help me debug it.
AI walks you through debugging step by step...

# Autonomous delegation 
$ gh agent-task create "Fix the database performance issues we just found"
AI goes away and comes back with a solution...

The combination is what makes this significant. You can brainstorm with one AI and delegate work to another. You can get instant feedback and long-term project execution. You can think fast and build thoroughly.

How Teams Will Actually Work
#

The most successful engineering teams are going to figure out how to split work between humans and AI effectively, and I think the division is becoming clearer.

Humans will still own the strategic decisions - architecture choices, priority setting, customer conversations. We’re also better at the ethical considerations and creative problem-solving when systems behave in unexpected ways. These require judgment, empathy, and the ability to see broader business context.

AI, on the other hand, is already excellent at maintaining consistency. It can keep code quality standards across a large codebase, write comprehensive test suites, monitor for security issues, and update documentation as code changes. These tasks require attention to detail and pattern recognition, but not creativity or judgment.

The interesting middle ground is where human expertise combines with AI execution. Code reviews will likely split this way: AI handles the mechanical checks for style violations and obvious bugs, while humans focus on logic, design decisions, and architectural implications. Planning becomes collaborative too - AI can suggest tasks based on codebase analysis, but humans decide priorities based on business needs.

Where This Is Really Heading
#

Here’s the part that gets me excited: we’re building systems that can improve themselves. Once AI can write code, test it, deploy it, monitor how it performs, and learn from the results, we’re not talking about tools anymore. We’re talking about software that evolves on its own.

# Imagine AI analyzing its own work
gh agent-task create "Look at all the code changes I've made this month. \
 Which ones worked well? Which ones caused problems? \
 Update your approach based on what you learned."

That’s a feedback loop that gets better over time. The AI learns from its successes and failures, just like a human developer would.

What You Should Do Right Now
#

Both tools are available today, though they’re still in preview status. Before you can use them, you’ll need a GitHub Copilot Pro+ subscription, and if you’re in an organization, make sure the CLI policy is enabled. Keep in mind that since these are preview features, they may change significantly without notice.

Getting started is straightforward - update your GitHub CLI to version 2.80.0 with gh --upgrade and install the standalone Copilot CLI with npm install -g @github/copilot. But the real strategy is in how you use them together.

Start with quick wins rather than trying to automate everything at once. Use the Copilot CLI for those daily terminal tasks you’re always googling - you’ll be surprised how much faster it is than switching to a browser. For agent-tasks, pick one annoying maintenance job you do weekly and delegate that first.

As you get comfortable, you’ll start to notice a natural rhythm emerging. The Copilot CLI becomes your thinking partner for quick questions and planning, while agent-tasks handle anything that takes more than fifteen minutes of sustained work. The real breakthrough happens when you start chaining them together - using insights from the interactive CLI to inform the work you delegate to the coding agent.

The teams that figure out this combination first are going to operate at a completely different level. They won’t just ship faster. They’ll build intelligent systems that improve themselves while the team focuses on innovation and strategy rather than maintenance and routine tasks.

When CI/CD Speaks Human: A Friendly Nudge to DevOps (and Developers)

Wed, 17 Sep 2025 00:00:00 +0000

I spend my days thinking about how to make engineering teams more effective. Whether it’s rolling out AI tooling that boosts developer productivity or exploring automation that eliminates the tedious parts of our workflow, I’m always looking for that next breakthrough that will let us focus on what actually matters: building great software.

That’s why GitHub Next’s Agentic Workflows project hit me like a lightning bolt. This isn’t just another automation tool, it’s a fundamental shift in how we’ll think about CI/CD, repository management, and team coordination.

What’s the idea?
#

GitHub Agentic Workflows transforms natural language markdown files into GitHub Actions that are executed by AI agents. You write automation in markdown instead of complex YAML, letting AI-powered decision making handle the details while maintaining GitHub’s native security and collaboration model.

The workflow is straightforward: install the GitHub CLI extension with gh extension install githubnext/gh-aw, describe your automation in a markdown file with frontmatter specifying triggers and permissions, then compile it to standard Actions YAML with gh aw compile. The system supports multiple AI engines (Claude, Codex, and others) and maintains security through sandboxed execution with minimal permissions.

This is explicitly a research demonstrator from GitHub Next and Microsoft Research, not a production product. The goal is to explore “Continuous AI”, the systematic, automated application of AI to software collaboration, and learn out in the open.

The design is Actions-first (familiar GitHub execution model) and engine-neutral (swap AI backends as needed). Your markdown source remains the source of truth, while the compiled YAML integrates seamlessly with existing GitHub workflows and governance.

How this will transform DevOps teams (if used carefully)
#

I’ve been watching multiple DevOps teams spend countless hours on repetitive investigative work—debugging CI failures, triaging flaky tests, writing post-mortems that follow the same patterns. Agentic Workflows could automate the tedious parts while keeping humans firmly in control.

Here’s what I’m most excited about:

Automated CI failure investigation — Think “CI Doctor” workflows that automatically investigate build failures and flakiness, then open Issues with their findings and suggested actions. No more manual time spent on repetitive post-mortem analysis. The AI does the legwork; your team makes the decisions.

Effortless status reporting — Weekly research reports and daily status updates delivered as scheduled Issues. Better visibility into what’s happening across your infrastructure without modifying a single pipeline. The information just appears where your team already looks.

Organization-specific guardrails — This is crucial. Role-based execution limits, “plan→apply” workflows with human approval checkpoints, and integrated MCP tools all running in sandboxed, network-confined environments. You get the automation benefits without losing control.

The key insight: your governance model doesn’t change. These workflows compile to standard GitHub Actions, so your existing review processes, permissions, and audit trails remain intact.

How this will supercharge Development teams
#

I’ve watched developers get buried under the administrative overhead of modern development—triaging issues, chasing missing PR details, manually updating documentation that should sync automatically. Here’s where I see Agentic Workflows making the biggest difference:

Intelligent triage that actually works — Workflows that request missing details from issue reporters, automatically categorize and label new issues, and reduce the noise that constantly interrupts focused development time. Finally, a way to maintain issue quality without developers playing 20 questions.

PR assistance with real context — Code-aware workflows that update documentation when APIs change, check dependencies for known issues, suggest fixes when PR builds fail, and identify opportunities to improve test coverage or performance. Crucially, all delivered through PRs that developers can review and approve—never silent changes to your codebase.

Continuous research and knowledge sharing — Workflows that create Issues with summaries of relevant trends, new tools, or techniques in your domain. Instead of wondering what you’re missing in the ecosystem, the information comes to you where you already work.

Here’s a simple example that captures the magic—an issue clarifier that runs when issues are opened:

---
on:
 issues:
 types: [opened]
permissions: read-all
safe-outputs:
 add-comment:
---
# Issue Clarifier
Analyze the current issue and ask for additional details if the issue is unclear.

That’s it. English instructions that compile to Actions YAML your team can review and govern.

Special caution regarding code changes
#

Here’s where I want to be crystal clear: any workflow that touches your actual codebase must go through pull requests for human review. The beauty of this system is that AI agents can suggest changes, improvements, and fixes, but they deliver them through the same PR process your team already trusts.

I’ve seen too many automation projects fail because they bypassed human oversight. The GitHub team got this right—workflows that modify code create PRs, not direct commits. This preserves your team’s ability to review, discuss, and reject changes that don’t make sense.

My pragmatic advice
#

Start small and specific. Pick one repetitive task that’s eating your team’s time—issue triage, status reporting, or CI failure investigation.
Security is non-negotiable. Use the read-only defaults, explicit tool allow-lists, and human-visible outputs. This is research-grade software; treat it accordingly.
Governance doesn’t change. Because it compiles to Actions YAML, your existing review processes, branch protections, and policies still apply. This is an authoring tool, not a permission bypass.
Keep humans in the loop. The goal isn’t to eliminate human judgment—it’s to eliminate human busy work.

Why I think this is the future
#

I’ve spent years watching teams struggle with the gap between intent and implementation. Developers know what they want their CI/CD to do, but getting there requires wrestling with YAML syntax, learning platform-specific APIs, and debugging workflows that should just work.

Agentic Workflows flips this: you describe what you want, and the system handles the how. Your DevOps team keeps control over policies, permissions, and infrastructure. Your developers get to focus on features instead of YAML archaeology.

Most importantly, everything stays auditable, reviewable, and governed through the same processes your team already trusts.

Ready to try it?
#

If you’re curious (and you should be), the quick start is genuinely quick:

Install the extension: gh extension install githubnext/gh-aw
Add a sample workflow: gh aw add weekly-research -r githubnext/agentics --pr
Set up your AI secret: gh secret set ANTHROPIC_API_KEY -a actions --body "<your-key>"
Run it: gh aw run weekly-research

Start with something low-risk—issue triage, status reports, or CI failure investigation. Keep approvals enabled, review everything the system generates, and learn what works for your team.

Key resources:

Main extension: githubnext/gh-aw
Sample workflows: githubnext/agentics

This is where engineering productivity is heading. The question isn’t whether AI will change how we automate our workflows—it’s whether we’ll be ready when it does.

DevOps · PiniShv

Agentic Overwatch: Why Your Next Dev Team Will Look Like a NASA Control Room

Defining the term #

It was never just about code #

The governance gap #

Borrow the tier model from the NOC #

The human becomes the orchestrator #

The handoff: ownership changes hands at the end of the day #

The Overwatch Maturity Model #

How to start before your agents force the issue #

The fleet doesn’t sleep #

100 Days to the EU AI Act Deadline. Your Engineering Team Hasn't Started.

Who this actually applies to #

What the law actually requires (in engineering language) #

Article 50: Transparency #

Article 12: Record-keeping #

Article 14: Human oversight #

Article 5: Prohibited practices #

Why the legal team isn’t the bottleneck #

The 100-day plan #

Days 1 to 15 (now through May 9): Inventory and triage #

Days 16 to 50 (May 10 through June 13): Build the audit layer #

Days 51 to 80 (June 14 through July 13): Disclosure and oversight #

Days 81 to 100 (July 14 through August 2): Documentation and dry-runs #

The one thing that blows up the plan #

What to do this week #

OpenClaw Is Not a Chatbot. It's a Personal Agent Gateway.

What OpenClaw actually is #

Why this is different from browser-based AI #

What it can actually do #

How people actually use it #

The hard truth about running it #

Who’s behind it #

How it compares to the incumbents #

How it compares to open-source alternatives #

What this means #

Open WebUI Isn't a ChatGPT Clone. It's AI Infrastructure.

What Open WebUI actually is #

What it can actually do (beyond chat) #

The reality of running it in production #

Who’s behind it and why that matters #

The security conversation nobody wants to have #

Why teams and orgs actually adopt this #

How it compares to the incumbents #

How it compares to open-source alternatives #

What this actually means for engineering leaders #

Who should care about this #

Your AI Agents Are Flying Blind. Here's How to Fix That.

Two teams, same agents, wildly different results #

Where knowledge actually lives (and why that’s broken) #

The wrong way to fix this #

What actually works: a developer knowledge hub #

Git for authoring #

Semantic search for retrieval #

MCP for delivery #

The loop that makes it compound #

The AGENTS.md safety net #

Why nothing on the market solves this #

How to start (without boiling the ocean) #

The uncomfortable question #

Ship Faster Without Breaking Things: DORA 2025 in Real Life

First, what DORA actually measures #

What changed in 2025 #

The big idea: capabilities beat tools #

1. Write down your AI stance #

Leader move #

2. Give AI your company context #

Developer move #

Leader move #

3. Make version control your safety net #

Developer move #

4. Work in smaller batches #

Team move #

5. Keep the user in the room #

Leader move #

6. Invest in platform quality #

Leader move #

7. Use value stream management so local wins become company wins #

Leader move #

Quick playbooks #

Defining the term
#

It was never just about code
#

The governance gap
#

Borrow the tier model from the NOC
#

The human becomes the orchestrator
#

The handoff: ownership changes hands at the end of the day
#

The Overwatch Maturity Model
#

How to start before your agents force the issue
#

The fleet doesn’t sleep
#

Who this actually applies to
#

What the law actually requires (in engineering language)
#

Article 50: Transparency
#

Article 12: Record-keeping
#

Article 14: Human oversight
#

Article 5: Prohibited practices
#

Why the legal team isn’t the bottleneck
#

The 100-day plan
#

Days 1 to 15 (now through May 9): Inventory and triage
#

Days 16 to 50 (May 10 through June 13): Build the audit layer
#

Days 51 to 80 (June 14 through July 13): Disclosure and oversight
#

Days 81 to 100 (July 14 through August 2): Documentation and dry-runs
#

The one thing that blows up the plan
#

What to do this week
#

What OpenClaw actually is
#

Why this is different from browser-based AI
#

What it can actually do
#

How people actually use it
#

The hard truth about running it
#

Who’s behind it
#

How it compares to the incumbents
#

How it compares to open-source alternatives
#

What this means
#

What Open WebUI actually is
#

What it can actually do (beyond chat)
#

The reality of running it in production
#

Who’s behind it and why that matters
#

The security conversation nobody wants to have
#

Why teams and orgs actually adopt this
#

How it compares to the incumbents
#

How it compares to open-source alternatives
#

What this actually means for engineering leaders
#

Who should care about this
#

Two teams, same agents, wildly different results
#

Where knowledge actually lives (and why that’s broken)
#

The wrong way to fix this
#

What actually works: a developer knowledge hub
#

Git for authoring
#

Semantic search for retrieval
#

MCP for delivery
#

The loop that makes it compound
#

The AGENTS.md safety net
#

Why nothing on the market solves this
#

How to start (without boiling the ocean)
#

The uncomfortable question
#

First, what DORA actually measures
#

What changed in 2025
#

The big idea: capabilities beat tools
#

1. Write down your AI stance
#

Leader move
#

2. Give AI your company context
#

Developer move
#

Leader move
#

3. Make version control your safety net
#

Developer move
#

4. Work in smaller batches
#

Team move
#

5. Keep the user in the room
#

Leader move
#

6. Invest in platform quality
#

Leader move
#

7. Use value stream management so local wins become company wins
#

Leader move
#

Quick playbooks
#

For developers
#

For engineering leaders
#

The takeaway
#

Two Different Tools, One Big Vision
#

Tool 1: GitHub CLI 2.80.0 with Agent Tasks
#

Tool 2: Standalone Copilot CLI
#

The Key Difference
#