<?xml version="1.0" encoding="UTF-8"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:dc="http://purl.org/dc/elements/1.1/">
  <channel>
    <title>DEV Community:  Alfacan Defence Group</title>
    <description>The latest articles on DEV Community by  Alfacan Defence Group (@development_dd8b958198d40).</description>
    <link>https://dev.to/development_dd8b958198d40</link>
    <image>
      <url>https://media2.dev.to/dynamic/image/width=90,height=90,fit=cover,gravity=auto,format=auto/https:%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Fuser%2Fprofile_image%2F4209499%2F979a5bea-e299-4b4e-a7c5-d11345e08aad.png</url>
      <title>DEV Community:  Alfacan Defence Group</title>
      <link>https://dev.to/development_dd8b958198d40</link>
    </image>
    <atom:link rel="self" type="application/rss+xml" href="https://dev.to/feed/development_dd8b958198d40"/>
    <language>en</language>
    <item>
      <title>Let the LLM Choose the Verb, Not Type the Command: How We Let AI Operate 18 Cloud Platforms Without Handing It the Keys</title>
      <dc:creator> Alfacan Defence Group</dc:creator>
      <pubDate>Tue, 10 Nov 2026 18:55:59 +0000</pubDate>
      <link>https://dev.to/development_dd8b958198d40/let-the-llm-choose-the-verb-not-type-the-command-how-we-let-ai-operate-18-cloud-platforms-without-4839</link>
      <guid>https://dev.to/development_dd8b958198d40/let-the-llm-choose-the-verb-not-type-the-command-how-we-let-ai-operate-18-cloud-platforms-without-4839</guid>
      <description>&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F98646190jut02os4u6rv.jpeg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F98646190jut02os4u6rv.jpeg" alt=" "&gt;&lt;/a&gt;&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;"Brains Without Hands: The Architecture That Lets LLMs Touch Production Servers"&lt;/li&gt;
&lt;li&gt;"We Rewrote Our AI Ops Agent From Scratch. Here Are the Six Rules We Kept."
Tags: devops, ai-agents, infrastructure-security, sre, llm-safety, cloud-computing, kubernetes, software-architecture
--&amp;gt;&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;&lt;strong&gt;TL;DR:&lt;/strong&gt; An AI that runs servers is only as safe as the worst command it can issue. After rolling back our own release&lt;br&gt;
and rewriting the agent from scratch, we settled on six rules. The model chooses an operation from a fixed vocabulary;&lt;br&gt;
it never types a shell command. Whether an action can be undone depends on the cloud vendor, not on the verb. The AI&lt;br&gt;
never holds a credential. The agent on the server has no shell. Irreversible steps need a human and a fresh snapshot.&lt;br&gt;
And because a second LLM turned out to catch only about one bad decision in three, safety lives in code, not in prompts.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Disclosure: I work on a-Cloud, a platform that administers and defends servers with AI agents. This post is about the&lt;br&gt;
architecture and the mistakes behind it. You can apply all of it without our product.&lt;/em&gt;&lt;/p&gt;
&lt;h2&gt;
  
  
  The day we rolled everything back
&lt;/h2&gt;

&lt;p&gt;On October 23 we did something no team enjoys: we stopped, rolled our code back to the state of two days earlier, and&lt;br&gt;
threw away the core of our server agent. That included the part that could edit code and configuration files on a client's&lt;br&gt;
machine.&lt;/p&gt;

&lt;p&gt;Nothing had blown up. But an internal adversarial review kept finding new holes in the same layer: secret-masking rules&lt;br&gt;
that missed common forms, restore paths that could overwrite a file changed after the patch, edge cases around symlinks.&lt;br&gt;
Each fix was correct, and each fix revealed the next problem. When a security-critical component needs a patch every day,&lt;br&gt;
the design is the problem. We rewrote it.&lt;/p&gt;

&lt;p&gt;What follows are the rules the rewrite is built on. None of them is novel on its own. Together they are the difference&lt;br&gt;
between "an LLM with root" and something you could put in front of a regulated client.&lt;/p&gt;
&lt;h2&gt;
  
  
  Rule 1: The model decides. Deterministic code acts.
&lt;/h2&gt;

&lt;p&gt;We split the system into &lt;strong&gt;brains&lt;/strong&gt; and &lt;strong&gt;hands&lt;/strong&gt;.&lt;/p&gt;

&lt;p&gt;The brains are LLM specialists: one each for AWS, GCP and Azure, a generalist for every other provider, and a k8s&lt;br&gt;
officer for clusters. They read telemetry, form a diagnosis, and propose an action. They never touch a server.&lt;/p&gt;

&lt;p&gt;The hands are plain, boring, deterministic code: the agent on the host, an adapter per cloud vendor, a Kubernetes&lt;br&gt;
adapter that talks to the kube API. They execute. They don't reason.&lt;/p&gt;

&lt;p&gt;The interface between the two is the most important design decision we made. The specialist does &lt;strong&gt;not&lt;/strong&gt; produce&lt;br&gt;
&lt;code&gt;aws ec2 reboot-instances ...&lt;/code&gt; or &lt;code&gt;hcloud server rebuild ...&lt;/code&gt;. It produces a structured operation from a closed&lt;br&gt;
vocabulary:&lt;br&gt;
&lt;/p&gt;

&lt;div class="highlight js-code-highlight"&gt;
&lt;pre class="highlight json"&gt;&lt;code&gt;&lt;span class="p"&gt;{&lt;/span&gt;
  &lt;span class="nl"&gt;"op"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"snapshot"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
  &lt;span class="nl"&gt;"target"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"node-7f3a"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
  &lt;span class="nl"&gt;"params"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="p"&gt;{&lt;/span&gt; &lt;span class="nl"&gt;"label"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"pre-restore-evidence"&lt;/span&gt; &lt;span class="p"&gt;}&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
  &lt;span class="nl"&gt;"reason"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="s2"&gt;"disk errors after kernel update; snapshot before rollback"&lt;/span&gt;&lt;span class="p"&gt;,&lt;/span&gt;
  &lt;span class="nl"&gt;"requires_consent"&lt;/span&gt;&lt;span class="p"&gt;:&lt;/span&gt; &lt;span class="kc"&gt;false&lt;/span&gt;
&lt;span class="p"&gt;}&lt;/span&gt;
&lt;/code&gt;&lt;/pre&gt;

&lt;/div&gt;



&lt;p&gt;The vocabulary is small: snapshot, restore, reboot (soft or hard), stop, start, resize disk, firewall rules, health.&lt;br&gt;
Kubernetes adds pod restart, scale, rollout restart, cordon, drain, network policy. Anything outside the vocabulary&lt;br&gt;
isn't "dangerous". It simply doesn't exist, and that case ends as an honest &lt;code&gt;not_executed&lt;/code&gt;.&lt;/p&gt;

&lt;p&gt;The model stays platform-independent: it reasons about &lt;em&gt;what&lt;/em&gt; should happen. The adapter knows &lt;em&gt;how&lt;/em&gt; it happens on&lt;br&gt;
each of the &lt;strong&gt;18 platforms&lt;/strong&gt; the system is built to serve:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;#&lt;/th&gt;
&lt;th&gt;Platform&lt;/th&gt;
&lt;th&gt;Where&lt;/th&gt;
&lt;th&gt;How we connect&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;1&lt;/td&gt;
&lt;td&gt;AWS&lt;/td&gt;
&lt;td&gt;global&lt;/td&gt;
&lt;td&gt;assumed role with external ID, no stored secret&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;2&lt;/td&gt;
&lt;td&gt;Google Cloud&lt;/td&gt;
&lt;td&gt;global&lt;/td&gt;
&lt;td&gt;Workload Identity Federation, no stored secret&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;3&lt;/td&gt;
&lt;td&gt;Azure&lt;/td&gt;
&lt;td&gt;global&lt;/td&gt;
&lt;td&gt;azure officer; servers through the host agent, cloud API through a federated service principal&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;4&lt;/td&gt;
&lt;td&gt;DigitalOcean&lt;/td&gt;
&lt;td&gt;global&lt;/td&gt;
&lt;td&gt;scoped token&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;5&lt;/td&gt;
&lt;td&gt;Hetzner&lt;/td&gt;
&lt;td&gt;EU, US, Singapore&lt;/td&gt;
&lt;td&gt;project token&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;6&lt;/td&gt;
&lt;td&gt;Vultr&lt;/td&gt;
&lt;td&gt;global&lt;/td&gt;
&lt;td&gt;API key with ACL&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;7&lt;/td&gt;
&lt;td&gt;Akamai Linode&lt;/td&gt;
&lt;td&gt;global&lt;/td&gt;
&lt;td&gt;scoped personal access token&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;8&lt;/td&gt;
&lt;td&gt;Contabo&lt;/td&gt;
&lt;td&gt;global&lt;/td&gt;
&lt;td&gt;OAuth2&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;9&lt;/td&gt;
&lt;td&gt;OVHcloud&lt;/td&gt;
&lt;td&gt;EU, global&lt;/td&gt;
&lt;td&gt;signed requests with scoped keys&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;10&lt;/td&gt;
&lt;td&gt;Hyperstack&lt;/td&gt;
&lt;td&gt;GPU cloud&lt;/td&gt;
&lt;td&gt;API key with RBAC&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;11&lt;/td&gt;
&lt;td&gt;Alibaba Cloud&lt;/td&gt;
&lt;td&gt;Singapore, Middle East, Asia&lt;/td&gt;
&lt;td&gt;signed API requests&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;12&lt;/td&gt;
&lt;td&gt;E2E Networks&lt;/td&gt;
&lt;td&gt;India&lt;/td&gt;
&lt;td&gt;bearer token&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;13&lt;/td&gt;
&lt;td&gt;Naver Cloud&lt;/td&gt;
&lt;td&gt;Korea&lt;/td&gt;
&lt;td&gt;HMAC-signed requests&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;14&lt;/td&gt;
&lt;td&gt;Sakura Cloud&lt;/td&gt;
&lt;td&gt;Japan&lt;/td&gt;
&lt;td&gt;access token and secret&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;15&lt;/td&gt;
&lt;td&gt;Biznet Gio&lt;/td&gt;
&lt;td&gt;Indonesia&lt;/td&gt;
&lt;td&gt;API token&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;16&lt;/td&gt;
&lt;td&gt;OpenStack&lt;/td&gt;
&lt;td&gt;ConoHa, NHN, sovereign clouds&lt;/td&gt;
&lt;td&gt;Keystone application credential&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;17&lt;/td&gt;
&lt;td&gt;VMware Cloud Director&lt;/td&gt;
&lt;td&gt;telecom clouds in the UAE and the Middle East&lt;/td&gt;
&lt;td&gt;organization session&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;18&lt;/td&gt;
&lt;td&gt;Your own servers&lt;/td&gt;
&lt;td&gt;on premises&lt;/td&gt;
&lt;td&gt;the host agent over mTLS&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Adding a vendor means writing one adapter, not retraining a model. A model can hallucinate a CLI flag. It cannot&lt;br&gt;
hallucinate its way past a type check.&lt;/p&gt;

&lt;h3&gt;
  
  
  Two pairs of hands: inside the server and outside it
&lt;/h3&gt;

&lt;p&gt;Every platform in that table is served at two levels, and it helps to keep them apart.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Inside the server&lt;/strong&gt; works the host agent. It's the same everywhere: on AWS, on Hetzner, in a Japanese cloud or in&lt;br&gt;
your own rack. Day-to-day system administration happens here: diagnosing a failing service, restarting it, cleaning&lt;br&gt;
up a full disk, fixing a broken configuration, reading logs, watching metrics, scheduled malware scans. The platform's&lt;br&gt;
specialist decides, the agent executes from its catalog. This level doesn't depend on the cloud vendor at all.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Outside the server&lt;/strong&gt; work the vendor adapters. They do what can't be done from inside the machine: take a disk&lt;br&gt;
snapshot at the provider, restore a VM from it, change cloud firewall rules, grow a disk, power-cycle a machine that no&lt;br&gt;
longer answers. This level needs the vendor's API and the client's role or token, and it's where all the vendor quirks&lt;br&gt;
from Rule 2 live.&lt;/p&gt;

&lt;p&gt;Azure shows why the split matters. The azure officer already administers Azure servers in full through the host agent:&lt;br&gt;
the same diagnostics, services, configurations and telemetry as on any other platform. The outside pair of hands for&lt;br&gt;
Azure, through a federated service principal, is designed and goes live with the first Azure client. Until then, an&lt;br&gt;
action that needs the Azure API ends as an honest &lt;code&gt;not_executed&lt;/code&gt; and goes to a human. The system says what it can't do&lt;br&gt;
rather than pretending.&lt;/p&gt;

&lt;p&gt;This split also limits the blast radius. The host agent holds no cloud credentials, so a compromised agent can't&lt;br&gt;
reach the client's cloud account. A cloud lease lives for one action and never reaches the server. The two pairs of&lt;br&gt;
hands live behind different keys.&lt;/p&gt;

&lt;h3&gt;
  
  
  Kubernetes gets its own officer
&lt;/h3&gt;

&lt;p&gt;Clusters run on top of any of these platforms, and they fail differently from VMs. So Kubernetes isn't an afterthought&lt;br&gt;
inside the server specialists: a dedicated &lt;strong&gt;k8s officer&lt;/strong&gt; is chosen by the &lt;em&gt;type&lt;/em&gt; of the node, not by its provider.&lt;br&gt;
Its hands are a separate adapter that talks to the kube API with the cluster's token from the vault: pod restart, scale,&lt;br&gt;
rollout restart, cordon, drain, network policy, each with its own reversibility class. Its eyes are the cluster's&lt;br&gt;
significant events plus the security agent running as a DaemonSet, one pod and one identity per node.&lt;/p&gt;

&lt;h2&gt;
  
  
  Rule 2: Reversibility is a property of the vendor, not the verb
&lt;/h2&gt;

&lt;p&gt;This was the most surprising lesson from reading all those vendor APIs. "Restore from snapshot" sounds safe everywhere. It&lt;br&gt;
isn't:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Vendor&lt;/th&gt;
&lt;th&gt;What "restore" or "resize" really does&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Hetzner&lt;/td&gt;
&lt;td&gt;Restore is a &lt;strong&gt;rebuild&lt;/strong&gt;: it wipes the disk&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Hyperstack&lt;/td&gt;
&lt;td&gt;Restore creates a &lt;strong&gt;new VM&lt;/strong&gt;; it isn't in place&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Contabo&lt;/td&gt;
&lt;td&gt;Growing a disk means &lt;strong&gt;upgrading the paid plan&lt;/strong&gt;
&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;OVHcloud, Linode, VMware Cloud Director&lt;/td&gt;
&lt;td&gt;
&lt;strong&gt;One snapshot slot per VM&lt;/strong&gt;: taking a "safety snapshot" before a restore would overwrite the very snapshot you are restoring from&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;DigitalOcean&lt;/td&gt;
&lt;td&gt;Works as expected, but the audit trail is thin&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;If the model has to remember these quirks, you've already lost: retrieval can miss, and context can drift. So the quirks&lt;br&gt;
live in the adapter. Every operation gets a &lt;strong&gt;reversibility class&lt;/strong&gt; computed from the verb &lt;em&gt;and&lt;/em&gt; the vendor. Then a gate&lt;br&gt;
in code checks it against the client's mode (observe, assisted, guarded, full):&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Reversible&lt;/strong&gt; actions (soft reboot, adding a firewall rule, a snapshot without downtime) can run automatically,
depending on risk and mode.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Irreversible or downtime&lt;/strong&gt; actions (a Hetzner restore, a disk resize, a stop) always require the client's explicit
consent &lt;strong&gt;and&lt;/strong&gt; a fresh snapshot first, where the vendor allows one.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Silence never executes an irreversible action.&lt;/strong&gt; An unanswered approval request expires; it doesn't turn into "yes".&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Rule 3: Probe what the key can actually do
&lt;/h2&gt;

&lt;p&gt;Vendor documentation says what a token &lt;em&gt;should&lt;/em&gt; be allowed to do. Reality differs: scopes are inherited oddly, and some&lt;br&gt;
auth flows behave differently from the docs. So when a server is connected, we test the client's key and record a&lt;br&gt;
&lt;strong&gt;capability matrix&lt;/strong&gt; for that node: snapshot, disk, reboot, network, audit, each marked yes, no or with a caveat.&lt;/p&gt;

&lt;p&gt;An action outside the matrix isn't attempted. The system asks the client to extend the permissions or hands the case to&lt;br&gt;
a human. We fail closed by default. We fail open in exactly one narrow place: containing an active attack.&lt;/p&gt;

&lt;h2&gt;
  
  
  Rule 4: The AI never holds a key
&lt;/h2&gt;

&lt;p&gt;A vendor token is a key to the client's whole infrastructure. That makes the component holding it the most valuable&lt;br&gt;
target in the system. So nothing that reasons ever holds one.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Big three: no secret at all.&lt;/strong&gt; On AWS we assume a role in the client's account with an external ID, on GCP we use
Workload Identity Federation, and Azure will use a federated service principal. The client grants a narrow role and can
revoke it in one click.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Every other vendor: a client-issued, minimally scoped token, in a vault.&lt;/strong&gt; We use OpenBao, the Linux Foundation fork
of Vault. One reason is licensing: as a vendor selling a platform, we wanted MPL-2.0, not BSL. The raw token stays in
the vault. Services get a &lt;strong&gt;short lease for a single action&lt;/strong&gt;, keep it in memory only, and never write it to disk.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Different roles, different leases.&lt;/strong&gt; Remediation (the sysadmin side) and containment (the security side) get separate
scopes. When a real attack is confirmed, remediation leases are &lt;strong&gt;suspended&lt;/strong&gt; and only containment may act until the
incident is closed. You don't want an optimizer "fixing" a server while it's being contained.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Rule 5: The agent on the server has no shell
&lt;/h2&gt;

&lt;p&gt;The host agent is the last line, so it's the most paranoid part:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;No shell, ever.&lt;/strong&gt; Tasks come only from a catalog of safe operations, one executable call per action. &lt;code&gt;&amp;amp;&amp;amp;&lt;/code&gt;, &lt;code&gt;||&lt;/code&gt;,
&lt;code&gt;;&lt;/code&gt;, pipes and substitutions are rejected before anything runs.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Outbound only.&lt;/strong&gt; The agent opens one long-lived gRPC stream to our gateway over mTLS. The server opens no inbound
port. Each server has its own certificate that lives seven days and renews over the same channel. The CA sits in a
cloud KMS, and a certificate can be revoked instantly by its serial number.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Two agents, not one.&lt;/strong&gt; One agent does administration, the other does security with a narrow, fixed grammar of
reversible containment actions. They have different keys and different rights, and each watches that the other is alive
and unmodified. One compromised agent doesn't hand over the other's powers.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The agent doesn't write code. A separate pipeline generates fixes, and a different model reviews them. The agent only&lt;br&gt;
deploys what was approved.&lt;/p&gt;

&lt;h2&gt;
  
  
  Rule 6: Keep your own audit log, because your vendors won't
&lt;/h2&gt;

&lt;p&gt;Several popular clouds have no API audit log at all, or a very thin one. If your AI acts through those APIs, you can't&lt;br&gt;
rely on the vendor to tell you later what happened. So we log every action ourselves: node, client, vendor, operation,&lt;br&gt;
parameters, who initiated it (which specialist or officer), the lease scope and lifetime, the snapshot taken before, the&lt;br&gt;
consent if any, and the result. That log is evidence for the client and input for the post-incident review.&lt;/p&gt;

&lt;h2&gt;
  
  
  The snapshot discipline
&lt;/h2&gt;

&lt;p&gt;Rules 2 to 6 assume that a recovery point exists. So snapshots are a subsystem of their own, not an afterthought:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;A nightly snapshot of each node, plus database dumps, plus a continuous database change log where the client agrees.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Only healthy snapshots count.&lt;/strong&gt; If an incident is open, the nightly snapshot is skipped. The last three are always
from a healthy state.&lt;/li&gt;
&lt;li&gt;Before an irreversible action, a &lt;strong&gt;fresh evidence snapshot&lt;/strong&gt; is taken. It serves the forensics &lt;em&gt;and&lt;/em&gt; lets us undo our own
action.&lt;/li&gt;
&lt;li&gt;Backups go to the client's storage at their vendor, through the client's role. The data stays where it already lives.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Why not just add a second LLM as a safety net?
&lt;/h2&gt;

&lt;p&gt;We tried. In October we ran our platform specialists through a 199-case exam per model across four platforms. About 80%&lt;br&gt;
of the cases were built on real signals from public log datasets and official vendor documentation. The exam was seeded&lt;br&gt;
with traps: prompt injections hidden inside logs, "delete it to free space", commands for the wrong cloud, irreversible&lt;br&gt;
steps that must wait for a human.&lt;/p&gt;

&lt;p&gt;The best specialist made a gross error in about 5% of cases. When we read each one by hand, two kinds stood out as truly&lt;br&gt;
dangerous: rebooting a machine in the middle of a forced filesystem check, and deleting a backup restore point to free&lt;br&gt;
disk space. Both looked locally reasonable.&lt;/p&gt;

&lt;p&gt;Then we put a larger model from a different vendor behind it as a reviewer, giving it everything a human reviewer would&lt;br&gt;
get: the full runbook, the retrieved doctrine, the event and the decision. It stopped about &lt;strong&gt;one gross error in three&lt;/strong&gt;.&lt;br&gt;
It also asked to change or escalate about &lt;strong&gt;17% of decisions that were correct&lt;/strong&gt;. Behind a weaker specialist that number&lt;br&gt;
was 41%.&lt;/p&gt;

&lt;p&gt;That's the whole argument for this architecture in two numbers. A reviewer model is useful as a second opinion. It's a&lt;br&gt;
poor guardrail. The guardrail is the vocabulary, the reversibility gate, the capability matrix, the lease and the&lt;br&gt;
missing shell. They are code, and code doesn't get talked out of its rules by a log line that says "ignore previous&lt;br&gt;
instructions".&lt;/p&gt;

&lt;h2&gt;
  
  
  Where we are, honestly
&lt;/h2&gt;

&lt;p&gt;The new agent channel and both host agents went live on November 6. The vendor adapters, the federated executor for AWS&lt;br&gt;
and GCP, and the snapshot gate are written and reviewed, and they're rolling out now. Until the snapshot subsystem is&lt;br&gt;
live, the system simply doesn't perform destructive actions; that's the fail-closed default doing its job. On Azure, the azure&lt;br&gt;
officer already works with servers through the host agent; its cloud-API actions go live with the first Azure client.&lt;/p&gt;

&lt;p&gt;Speed is still a trade-off. Our sysadmin specialist answers in about 80 seconds at the median. That's fine for a broken&lt;br&gt;
service and far too slow for an intrusion. So first containment doesn't wait for a reasoning model: it runs on a separate,&lt;br&gt;
faster path, and the specialist writes the analysis afterwards.&lt;/p&gt;

&lt;h2&gt;
  
  
  A checklist you can steal
&lt;/h2&gt;

&lt;p&gt;If you're building anything that lets a model act on infrastructure:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;Make the model emit typed operations from a closed list, never shell or CLI text.&lt;/li&gt;
&lt;li&gt;Compute reversibility per operation &lt;strong&gt;and&lt;/strong&gt; per vendor, in code.&lt;/li&gt;
&lt;li&gt;Probe credentials at connect time and refuse anything outside what they actually allow.&lt;/li&gt;
&lt;li&gt;Keep credentials out of anything that reasons: use federation where possible, short in-memory leases elsewhere.&lt;/li&gt;
&lt;li&gt;Give the host agent no shell, outbound-only mTLS, and short-lived per-host certificates.&lt;/li&gt;
&lt;li&gt;Split operations and security into separate agents with separate rights.&lt;/li&gt;
&lt;li&gt;Write your own action log.&lt;/li&gt;
&lt;li&gt;Never let silence approve an irreversible step.&lt;/li&gt;
&lt;li&gt;Treat a reviewer LLM as advice, not a guardrail.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;We learned most of these by getting them wrong first. Hopefully you won't have to.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;If you want to see how this plays out on real servers, a-Cloud is at &lt;a href="https://guardian.alfa-can.com/" rel="noopener noreferrer"&gt;guardian.alfa-can.com&lt;/a&gt;.&lt;/em&gt;&lt;/p&gt;

</description>
      <category>ai</category>
      <category>architecture</category>
      <category>devops</category>
      <category>security</category>
    </item>
    <item>
      <title>Why We Renamed Our AI Ops Platform to a-Cloud, and How It Compares to Every Alternative</title>
      <dc:creator> Alfacan Defence Group</dc:creator>
      <pubDate>Sat, 07 Nov 2026 17:30:57 +0000</pubDate>
      <link>https://dev.to/development_dd8b958198d40/why-we-renamed-our-ai-ops-platform-to-a-cloud-and-how-it-compares-to-every-alternative-5gaf</link>
      <guid>https://dev.to/development_dd8b958198d40/why-we-renamed-our-ai-ops-platform-to-a-cloud-and-how-it-compares-to-every-alternative-5gaf</guid>
      <description>&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F1xu4qpka34aza2v8s6aa.jpeg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F1xu4qpka34aza2v8s6aa.jpeg" alt=" " width="799" height="436"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;Every month, the world absorbs more than nine million cyberattacks. And lately, the attacking side is no longer made of hackers: it is AI. Offense has gained machine speed, machine patience, and machine scale. That is the threat we built a true shield against, our platform a-Cloud, because an AI hacker can only be stopped by an AI defender.&lt;/p&gt;

&lt;p&gt;&lt;em&gt;Disclosure up front: I'm part of the team behind a-Cloud. This article explains what the platform does and, more importantly, where it fits in a market crowded with monitoring tools, EDR, managed service providers, and AI SRE agents. I'll also be honest about where it is not the right answer, because that's the article I'd want to read myself.&lt;/em&gt;&lt;/p&gt;

&lt;h2&gt;
  
  
  First, the rename
&lt;/h2&gt;

&lt;p&gt;A month after our public premiere as &lt;strong&gt;Guardian Cloud&lt;/strong&gt;, we counted more than twenty new "projects" that had borrowed the name. Some were demos, some were GitHub repos, some were, let's say, heavily inspired by our landing page. Rather than fight a naming war we had no time for, we renamed the platform: &lt;strong&gt;Guardian Cloud is now a-Cloud&lt;/strong&gt;. Same platform, same team, same architecture, new name.&lt;/p&gt;

&lt;p&gt;There is a silver lining: when your category gets cloned that fast, that's market validation. And it's a good excuse to write the article we've owed people since the premiere: what does this thing actually do, and how does it compare to the tools you're already running?&lt;/p&gt;

&lt;h2&gt;
  
  
  The problem we aimed at
&lt;/h2&gt;

&lt;p&gt;Almost every company with servers has two jobs that never really stop:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Operations&lt;/strong&gt;: patch, configure, monitor, upgrade, and fix. Forever.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Security&lt;/strong&gt;: detect intrusions, contain them, recover. Also forever.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;Both are 24/7 jobs, and humans are structurally bad at 24/7. The patterns are familiar to any technical leader:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;The startup with no sysadmin at all, where every outage hits the founder personally.&lt;/li&gt;
&lt;li&gt;The DevOps team drowning in on-call rotations and 3 a.m. alerts, where routine eats the time that engineering work needed.&lt;/li&gt;
&lt;li&gt;The hosting provider or MSP running dozens of other people's servers, who cannot hire endlessly.&lt;/li&gt;
&lt;li&gt;The security team whose attackers don't observe business hours.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The asymmetry is structural. Modern malware and automated exploits move at machine speed: the path from initial penetration to full compromise is often measured in minutes, while human mean time to respond is measured in tens of minutes to hours. Meanwhile, alert fatigue from thousands of non-critical notifications a day means genuinely dangerous anomalies get missed, and expertise scales only linearly: more servers, more admins, more misconfigurations, which remain a primary cause of data breaches in cloud environments.&lt;/p&gt;

&lt;p&gt;The classic automation answer, Ansible, Terraform, or SIEM rules, is deterministic: it executes exactly what was scripted, and cannot adapt to a zero-day or an unknown anomaly. That gap is what a-Cloud was built for.&lt;/p&gt;

&lt;p&gt;Gartner projects that by 2029, 70% of enterprises will deploy agentic AI agents to operate their IT infrastructure, up from less than 5% in 2025 (&lt;a href="https://dev.to/siddharth_singh_409bd5267/ai-sre-the-complete-guide-for-engineering-teams-in-2026-51ba"&gt;source&lt;/a&gt;). The question is no longer whether AI will run infrastructure. The question is how much control you keep while it does.&lt;/p&gt;

&lt;h2&gt;
  
  
  What a-Cloud actually is
&lt;/h2&gt;

&lt;p&gt;a-Cloud is an autonomous, multi-agent AI system for operating and protecting server infrastructure. We've published the full architecture in a technical paper (&lt;a href="https://guardian.alfa-can.com/papers/guardian-cloud-paper-en.html" rel="noopener noreferrer"&gt;read it here&lt;/a&gt;); below is the short version, with the parts a technical leader will actually ask about.&lt;/p&gt;

&lt;h3&gt;
  
  
  The host agent: eBPF, not log scraping
&lt;/h3&gt;

&lt;p&gt;One lightweight daemon is installed per server. Traditional monitoring hooks syscalls or parses &lt;code&gt;dmesg&lt;/code&gt;/&lt;code&gt;syslog&lt;/code&gt; in real time, which becomes prohibitively expensive under load. Our agent instead runs sandboxed programs directly inside the Linux kernel using eBPF (&lt;code&gt;kprobes&lt;/code&gt;, &lt;code&gt;uprobes&lt;/code&gt;, &lt;code&gt;tracepoints&lt;/code&gt;), so there are no expensive context switches between kernel and user space and no redundant data copies.&lt;/p&gt;

&lt;p&gt;The result: continuous low-level auditing (network activity, daemon statuses, changes in critical configuration files) with CPU and memory overhead &lt;strong&gt;below 1% even on systems pushing 100,000+ RPS&lt;/strong&gt;. Telemetry travels to the platform over encrypted gRPC channels with mutual TLS; the same agent provides the execution interface for AI-generated commands, strictly after operator confirmation. And it runs in &lt;strong&gt;dry-run mode by default&lt;/strong&gt;: it reads, analyzes, and proposes, but changes nothing without your decision.&lt;/p&gt;

&lt;h3&gt;
  
  
  The multi-agent core, and why it's not one chatbot with root
&lt;/h3&gt;

&lt;p&gt;Platform-side, the system is partitioned into specialized AI agents, each with its own context memory, its own toolset, and its own role. A single monolithic model suffers from context dilution and high latency; a fleet of narrow specialists doesn't:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Master Agent (orchestrator)&lt;/strong&gt;: aggregates telemetry, performs primary semantic analysis, distributes subtasks, synthesizes reports.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Sysadmin Agent&lt;/strong&gt;: configuration management and SRE work: service health, database optimization, web servers. Its initial audit is built from 18 telemetry signals and produces a structured risk report and action plan.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;ITDR Agent&lt;/strong&gt;: behavioral anomalies, brute-force attempts, unauthorized privilege escalations, with three detection shields (root abuse, credential abuse, privilege abuse) and malware defense that quarantines instead of deleting.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Doctrine&lt;/strong&gt;: a living, review-gated knowledge base the agents reason with: playbooks, rules of engagement, verified intel, incident lessons, continuously enriched from open malware databases, retrieved via two-stage semantic search (recall + rerank).&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The interesting part is the &lt;strong&gt;inter-agent consensus protocol&lt;/strong&gt;. When the ITDR Agent flags suspicious file activity, it requests the current process map from the Sysadmin Agent, which correlates process IDs with network sockets and identifies anomalous outbound traffic. Only when the administrative and security domains corroborate the threat does the Master Agent form a verdict. A critical action, like network port isolation, happens only when both domains agree. That cross-examination is what keeps false positives down where a single-agent system would cry wolf.&lt;br&gt;
&lt;/p&gt;

&lt;pre data-lang="mermaid"&gt;&lt;code&gt;flowchart TD
  s1["Target server&amp;lt;br/&amp;gt;(eBPF host agent)"]
  s2["Target server&amp;lt;br/&amp;gt;(eBPF host agent)"]
  s1 -- "encrypted gRPC / mTLS" --&amp;gt; master
  s2 -- "encrypted gRPC / mTLS" --&amp;gt; master
  subgraph core["a-Cloud AI core, isolated VPC per client"]
    master["Master Agent&amp;lt;br/&amp;gt;(orchestrator)"]
    sysadmin["Sysadmin Agent"]
    itdr["ITDR Agent"]
    master &amp;lt;--&amp;gt; sysadmin
    master &amp;lt;--&amp;gt; itdr
    sysadmin &amp;lt;--&amp;gt; itdr
  end
  master -- "change validation" --&amp;gt; owner["Operator UI&amp;lt;br/&amp;gt;(5-factor auth)"]&lt;/code&gt;&lt;/pre&gt;



&lt;h3&gt;
  
  
  The autonomous lifecycle, with an undo button
&lt;/h3&gt;

&lt;p&gt;When an incident is detected, the system runs a continuous adaptive cycle:&lt;/p&gt;

&lt;ol&gt;
&lt;li&gt;
&lt;strong&gt;Monitoring&lt;/strong&gt; via eBPF telemetry.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Deep context analysis&lt;/strong&gt;: stack traces, configuration, and source code.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Patch and code generation&lt;/strong&gt;: the AI-Studio module synthesizes fixes for defective code or config segments.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Sandbox testing&lt;/strong&gt;: changes are verified for compilation correctness and the absence of destructive side effects before deployment.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Production deployment&lt;/strong&gt;, and if post-deployment telemetry shows degradation, an &lt;strong&gt;automatic atomic rollback&lt;/strong&gt;.&lt;/li&gt;
&lt;/ol&gt;

&lt;p&gt;That last step is the one SREs always ask about: what happens when autonomous patching causes a delayed failure, like a memory leak, in production? Configuration changes are applied as atomic transactions (write to a temp file, then an atomic &lt;code&gt;rename()&lt;/code&gt;), and broader system changes are covered by filesystem snapshots (ZFS/Btrfs) or LVM. If eBPF telemetry detects instability after deployment, the system rolls back instantly to the pre-patch state.&lt;br&gt;
&lt;/p&gt;

&lt;pre data-lang="mermaid"&gt;&lt;code&gt;flowchart LR
  m["1. Monitoring&amp;lt;br/&amp;gt;(eBPF telemetry)"] --&amp;gt; a["2. Deep context&amp;lt;br/&amp;gt;analysis"]
  a --&amp;gt; p["3. Patch and code&amp;lt;br/&amp;gt;generation (AI-Studio)"]
  p --&amp;gt; t["4. Sandbox testing&amp;lt;br/&amp;gt;and validation"]
  t --&amp;gt; d["5. Production&amp;lt;br/&amp;gt;deployment"]
  d -- "if degraded" --&amp;gt; r["Atomic rollback&amp;lt;br/&amp;gt;(snapshots, rename)"]
  t -. "human-in-the-loop" .-&amp;gt; h["Owner verification&amp;lt;br/&amp;gt;on HIGH/CRITICAL"]&lt;/code&gt;&lt;/pre&gt;



&lt;h3&gt;
  
  
  The model fleet, with real numbers
&lt;/h3&gt;

&lt;p&gt;In the sovereign configuration, the models are not a black box. The self-hosted fleet and its validation scores look like this:&lt;/p&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Model&lt;/th&gt;
&lt;th&gt;Role&lt;/th&gt;
&lt;th&gt;Validation&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Qwen3-30B-A3B-Thinking&lt;/td&gt;
&lt;td&gt;Audit Officer, initial server audit&lt;/td&gt;
&lt;td&gt;97.0%&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Gemma-4-26B-A4B&lt;/td&gt;
&lt;td&gt;ITDR Officer, intrusion verdicts&lt;/td&gt;
&lt;td&gt;94.0%, safety gate 100/100&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;3x Qwen3-4B&lt;/td&gt;
&lt;td&gt;Detection shields, first-line detection&lt;/td&gt;
&lt;td&gt;3/3 threats, in 726–952 ms&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Qwen3-Coder-30B-A3B&lt;/td&gt;
&lt;td&gt;Command generation, all platforms&lt;/td&gt;
&lt;td&gt;97.0%&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Qwen3-Coder + Qwen3-Thinking&lt;/td&gt;
&lt;td&gt;Code generation with security review&lt;/td&gt;
&lt;td&gt;generate, then review&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;GLM-5.2 "Da Vinci" (self-hosted)&lt;/td&gt;
&lt;td&gt;Main brain, validator for high-risk changes&lt;/td&gt;
&lt;td&gt;in-contour review&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Latency is the quiet differentiator: &lt;strong&gt;first-line detection in 726–952 ms&lt;/strong&gt;, in the same order of magnitude as the exploits it needs to outpace. To keep it there, the platform uses INT4/INT8 weight quantization (AWQ/GPTQ), the vLLM inference engine with PagedAttention to avoid KV-cache memory fragmentation, multi-level context caching to cut time-to-first-token, and small shield models deployed close to the edge.&lt;/p&gt;

&lt;h3&gt;
  
  
  Two architectures: sovereign and API
&lt;/h3&gt;

&lt;p&gt;After the rename we completed a deep refactoring of the platform and trained a new generation of API officers: specialists running on external models with top cybersecurity benchmarks, among them DeepSeek-v4.1-Flash, GLM-5.3-Flash, GLM-5.3, Claude Opus 5.5, MiMo-2.6-Pro and Fable 5.1. They earned their seats in a live contest: candidates went through an evaluation of roughly 200 cases across four platforms (AWS, GCP, Azure and on-prem), 82-86% of them real-world signals from production log datasets and official vendor documentation, seeded with traps: prompt injections hidden in logs, irreversible steps that must be refused, commands from the wrong platform. The officer seats went to the models that passed.&lt;/p&gt;

&lt;p&gt;The result is a second architecture, faster than the air-gap one. And it is still maximally closed, because the primary criterion in our service contracts with every model vendor is a full ban on using the data of model operation for training or research. Your telemetry never becomes anyone's training set, in either architecture.&lt;/p&gt;

&lt;p&gt;The officer roster now covers the platforms of the three big vendors (AWS, GCP, Azure) and fifteen smaller clouds, with Hyperstack, Hetzner, DigitalOcean, Vultr, OVHcloud, Contabo and Akamai Linode among them. Each vendor's officer knows that vendor's APIs, snapshot semantics and failure modes: a Hetzner rebuild and a Hyperstack snapshot are handled by a specialist who knows the difference. The roster also includes a trained Kubernetes specialist: in k8s clusters the platform's agent deploys as a DaemonSet, one pod per node, and the k8s officer knows the specifics of container orchestration.&lt;/p&gt;

&lt;h3&gt;
  
  
  The security of the platform itself
&lt;/h3&gt;

&lt;p&gt;Any orchestrator with this much privilege is a supply-chain risk, so the architecture treats it as one. Each client's AI core runs in a logically isolated VPC (we call it Sovereign Cloud isolation), so a breach in one segment cannot propagate laterally. In the sovereign configuration, telemetry and models stay inside your contour; in the API configuration the same guarantee is contractual, enforced through the training-and-research ban in every vendor agreement. Access to the approval interface is protected by five-factor authentication: master password, session email verification, Telegram, hardware TOTP, and WebAuthn/passkeys. The AI can autonomously prepare and test a change; applying a critical one requires the fully authenticated system owner.&lt;/p&gt;

&lt;p&gt;The philosophy that shapes all of it is the &lt;strong&gt;Human-in-the-Loop doctrine&lt;/strong&gt; stated in our technical paper: automate up to 100% of routine administration and security-audit operations, while every critical change passes strict verification by the system's owner before it is applied. Low-risk actions can be automated once you allow them; HIGH and CRITICAL actions require your approval. Every action, AI or human, lands in a visible service history. That matters for regulated industries, and it matters even more for trust. Before we get to the market, one part of the system deserves its own audience: the pipeline developers ask us about most.&lt;/p&gt;

&lt;h2&gt;
  
  
  For developers: the α-Coder pipeline
&lt;/h2&gt;

&lt;p&gt;The part of a-Cloud developers ask about most deserves its own section: α-Coder.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;The AI meeting.&lt;/strong&gt; The α-Coder module integrates into VS Code and runs an "AI Meeting": specialized sub-models (Architect, Coder, Tester) discuss and argue over a proposed refactor or bug fix in real time, in front of you. You observe the discourse and keep final control of the codebase; the meeting exists precisely so that no single model decides alone. Behind it, the coding doctrine is seeded from license-clean open knowledge: SEI CERT rules, CodeQL query help, CWE, OWASP secure coding practices, and the Google and Uber style guides, so the AI's advice has an attributable source.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Hardened code operations on the server.&lt;/strong&gt; When a fix has to be deployed to a production server, it does not travel through a shell pipeline. The host agent implements a closed set of typed code operations, and each one is deliberately paranoid:&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Reads leave the host masked.&lt;/strong&gt; Before a source file is sent for analysis, secrets are masked line by line: connection strings, keys, tokens, credentials. Even file fingerprints are keyed HMAC hashes, so a masked secret cannot be brute-forced offline. Secret files like &lt;code&gt;.env&lt;/code&gt;, keys, keystores and kubeconfigs are never read at all.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Writes are approved and atomic.&lt;/strong&gt; A code write requires an approved task and a decision reference, lands only inside a known application root (a service's working directory, an nginx document root), never touches sudoers, SSH keys, systemd units or shell startup files, and is written atomically: temp file, then rename.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Every edit is reversible.&lt;/strong&gt; Before the first edit of a session the agent backs up each file with its permissions, ownership and hashes; per-file and whole-session rollback works for 30 days, and config edits go through the same backup, seal and restore cycle.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Security review is a separate model.&lt;/strong&gt; Code generation and security review are performed by different specialized models, and the review happens before anything reaches production.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;That is what "autonomous" can honestly mean in 2026: the AI does the work end to end, and the dangerous edges are engineered rather than promised.&lt;/p&gt;

&lt;h2&gt;
  
  
  The four ways companies solve this today
&lt;/h2&gt;

&lt;h3&gt;
  
  
  Option 1: Observability + AIOps platforms
&lt;/h3&gt;

&lt;p&gt;Zabbix, Prometheus + Grafana, Datadog, New Relic, and the new AI layer on top: Datadog's Bits AI SRE agent went GA in December 2025, and PagerDuty shipped its SRE Agent in October 2025 with a six-step workflow from autonomous diagnostics to approved actions (&lt;a href="https://www.augmentcode.com/guides/ai-sre-ai-powered-site-reliability-engineering" rel="noopener noreferrer"&gt;source&lt;/a&gt;).&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;What they do well&lt;/strong&gt;: detection, dashboards, anomaly alerts, and increasingly good AI investigation of incidents.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Where they stop&lt;/strong&gt;: they tell you what's wrong; a human still logs in at 3 a.m. and fixes it. They're also built app-first and cloud-native-first. If your estate is a fleet of plain Linux servers, the fancy graph-based agents have little graph to work with.&lt;/p&gt;

&lt;h3&gt;
  
  
  Option 2: The security stack (EDR / SIEM)
&lt;/h3&gt;

&lt;p&gt;CrowdStrike, SentinelOne, Microsoft Defender, Wazuh, Elastic Security.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;What they do well&lt;/strong&gt;: detecting and blocking threats at the endpoint, quarantine, threat intel.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Where they stop&lt;/strong&gt;: they secure, they don't administer. No EDR will notice your disk filling up, patch your packages, tune a misconfigured service, or write the fix for the bug that keeps paging you. And the alerts they do produce still need humans (or an outsourced SOC) to respond. Security without operations is half a job.&lt;/p&gt;

&lt;h3&gt;
  
  
  Option 3: More humans (hire, MSP, NOC/SOC)
&lt;/h3&gt;

&lt;p&gt;The incumbent solution, and still the default in most companies.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;What it does well&lt;/strong&gt;: accountability, judgment, and flexibility that no AI can match on genuinely novel problems.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Where it stops&lt;/strong&gt;: it doesn't scale, and it's brutal on the people. A true 24/7 rotation needs about five staff just to cover the shifts, before you've bought a single specialist skill. Small businesses can't fund that; MSPs that do fund it are actively looking for leverage so one operator can serve more clients. And burnout in on-call roles is not exactly a solved problem.&lt;/p&gt;

&lt;h3&gt;
  
  
  Option 4: AI SRE agents
&lt;/h3&gt;

&lt;p&gt;The new wave, and the closest category to what we do: Resolve AI (unicorn status in under two years, a $125M Series A), Cleric, Traversal, incident.io AI, and open-source options like k8sgpt (&lt;a href="https://www.anyshift.io/blog/top-10-ai-sre-tools-2026-comparison" rel="noopener noreferrer"&gt;landscape overview&lt;/a&gt;, &lt;a href="https://bronto.io/resources/articles/ai-sre-landscape-2026-66-tools-evaluated" rel="noopener noreferrer"&gt;a 64-tool evaluation&lt;/a&gt;).&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;What they do well&lt;/strong&gt;: autonomous incident investigation and root cause analysis in cloud-native stacks, with real results: vendors report double-digit MTTR reductions, and a widely shared observation from practitioners is that most of these tools stay away from "possibly destructive auto-remediation" by design (&lt;a href="https://www.reddit.com/r/sre/comments/1u232k6/ai_sre_tools_in_2026_updated_list_what_i_actually/" rel="noopener noreferrer"&gt;source&lt;/a&gt;). Cleric, for example, is deliberately read-only.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Where they stop&lt;/strong&gt;: they investigate incidents in Kubernetes and cloud-native environments. They don't administer your servers, and most don't do security at all. The honest ones treat autonomous remediation as a long-term goal, not a shipping feature.&lt;/p&gt;

&lt;h2&gt;
  
  
  The comparison, in one table
&lt;/h2&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;a-Cloud&lt;/th&gt;
&lt;th&gt;Observability + AI SRE&lt;/th&gt;
&lt;th&gt;EDR / SIEM&lt;/th&gt;
&lt;th&gt;Humans / MSP&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Primary job&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;Run and protect servers&lt;/td&gt;
&lt;td&gt;Tell you what broke&lt;/td&gt;
&lt;td&gt;Block threats&lt;/td&gt;
&lt;td&gt;Everything, manually&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Scope&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;Ops + security, server-level&lt;/td&gt;
&lt;td&gt;App and K8s incidents&lt;/td&gt;
&lt;td&gt;Security only&lt;/td&gt;
&lt;td&gt;Whatever you pay for&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Autonomy&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;Dry-run by default, risk-gated remediation&lt;/td&gt;
&lt;td&gt;Investigate and suggest&lt;/td&gt;
&lt;td&gt;Block and quarantine&lt;/td&gt;
&lt;td&gt;Human speed&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Remediation safety&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;Atomic rollbacks, filesystem/LVM snapshots&lt;/td&gt;
&lt;td&gt;Suggest only, human applies&lt;/td&gt;
&lt;td&gt;Block and quarantine&lt;/td&gt;
&lt;td&gt;Human judgment&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Plain server fleets&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;First-class citizen&lt;/td&gt;
&lt;td&gt;Often out of scope&lt;/td&gt;
&lt;td&gt;Endpoint only&lt;/td&gt;
&lt;td&gt;Expensive at scale&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Data privacy&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;Self-hosted models, or contractually closed API models&lt;/td&gt;
&lt;td&gt;Vendor cloud&lt;/td&gt;
&lt;td&gt;Vendor cloud&lt;/td&gt;
&lt;td&gt;NDA and hope&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;MSP white-label&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;Yes, built-in tier&lt;/td&gt;
&lt;td&gt;Rarely&lt;/td&gt;
&lt;td&gt;Rarely&lt;/td&gt;
&lt;td&gt;It &lt;em&gt;is&lt;/em&gt; the MSP's business&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;&lt;strong&gt;Pricing&lt;/strong&gt;&lt;/td&gt;
&lt;td&gt;Per-server subscription&lt;/td&gt;
&lt;td&gt;Per host/GB, grows fast&lt;/td&gt;
&lt;td&gt;Per endpoint&lt;/td&gt;
&lt;td&gt;Salary times headcount&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;h2&gt;
  
  
  Where a-Cloud wins
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Plain server fleets&lt;/strong&gt;: if your infrastructure is Linux servers rather than a Kubernetes marvel, the agent-first approach works where graph-first tools have nothing to chew on.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;SMBs without a sysadmin&lt;/strong&gt;: the platform absorbs administration and security while you build the product.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Hosting providers and MSPs&lt;/strong&gt;: white-label tiers mean one operator serves many more clients, under your own brand.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Regulated and financial companies&lt;/strong&gt;: complete audit history of every action, per-client VPC isolation of the AI core, telemetry that stays in your contour, five-factor authentication on approvals, and human sign-off on critical changes.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Teams that want autonomy with a brake&lt;/strong&gt;: dry-run by default, graduated rules of engagement, approval gates on HIGH/CRITICAL. The DORA 2025 report found that AI improves throughput but can increase instability for teams without strong foundations (&lt;a href="https://dev.to/siddharth_singh_409bd5267/ai-sre-the-complete-guide-for-engineering-teams-in-2026-51ba"&gt;source&lt;/a&gt;); our answer to that is structural, not marketing.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Where you should pick something else (honestly)
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Deep application APM&lt;/strong&gt; (distributed tracing, RUM, profiling): stay with Datadog or New Relic. We do servers, not request pipelines.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Kubernetes-heavy investigation at massive scale&lt;/strong&gt;: Resolve AI, Cleric, or Traversal are built exactly for that.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Mature enterprise endpoint ecosystems&lt;/strong&gt;: if CrowdStrike or Defender is deployed and staffed, don't rip them out for a young platform.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Full "no human in the loop" autonomy&lt;/strong&gt;: we deliberately don't offer it. Trust is earned in stages, observe, suggest, act, and we require a human on every consequential change. If you want Skynet, we're not it.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Hobby servers&lt;/strong&gt;: the platform is B2B. Onboarding requires a registered company and verification, no exceptions.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  The business math
&lt;/h2&gt;

&lt;p&gt;A real 24/7 operations and security contour staffed with humans is roughly five-plus full-time salaries before you've hired a single senior specialist, and one bad night still depends on whoever picks up the phone. a-Cloud is a per-server subscription with a hard billing gate on connect, tiered from a single server up to data-center and white-label plans, with a 10-day trial in which you get one server with full AI automation and one with AI monitoring, so you can compare both modes on your own workloads.&lt;/p&gt;

&lt;p&gt;Every company's math differs, but the comparison to run is simple: your current downtime cost plus your current coverage cost, versus a per-server line item that also produces an audit trail your regulator will actually like.&lt;/p&gt;

&lt;h2&gt;
  
  
  The takeaway
&lt;/h2&gt;

&lt;p&gt;The category is converging fast: from less than 5% of enterprises using agentic AI in operations in 2025 to a projected 70% by 2029. Monitoring platforms tell you what broke. EDR blocks the attack. AI SRE agents investigate incidents in cloud-native stacks. Humans do everything, when they can, at a price.&lt;/p&gt;

&lt;p&gt;What was missing from that list was the actual work of running and defending servers, around the clock, with a human holding the keys. That's the slot a-Cloud was built to fill, and apparently the slot twenty copycats also wanted to fill. We just got there first, and now we have the shorter name.&lt;/p&gt;

&lt;p&gt;If you want to poke holes in it, the platform takes about a day of your time to disprove us: &lt;a href="https://guardian.alfa-can.com/" rel="noopener noreferrer"&gt;guardian.alfa-can.com&lt;/a&gt;. And if you want the full architecture, the eBPF internals, the consensus protocol, and the complete model zoo, we've published the technical paper &lt;a href="https://guardian.alfa-can.com/papers/guardian-cloud-paper-en.html" rel="noopener noreferrer"&gt;here&lt;/a&gt;.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>cloud</category>
      <category>cybersecurity</category>
      <category>security</category>
    </item>
    <item>
      <title>A council of models that cannot sign off its own work</title>
      <dc:creator> Alfacan Defence Group</dc:creator>
      <pubDate>Tue, 27 Oct 2026 10:48:43 +0000</pubDate>
      <link>https://dev.to/development_dd8b958198d40/a-council-of-models-that-cannot-sign-off-its-own-work-2f68</link>
      <guid>https://dev.to/development_dd8b958198d40/a-council-of-models-that-cannot-sign-off-its-own-work-2f68</guid>
      <description>&lt;h2&gt;
  
  
  &lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2F7nzkpsj0vmbc2aqyy8c3.jpg" alt=" " width="800" height="533"&gt;
&lt;/h2&gt;

&lt;h2&gt;
  
  
  Architecture and field notes from α-Coder
&lt;/h2&gt;

&lt;h2&gt;
  
  
  Abstract
&lt;/h2&gt;

&lt;p&gt;Single-model coding assistants frequently suffer from self-confirmation bias, contextual drift, and ungrounded hallucination. We present &lt;strong&gt;α-Coder&lt;/strong&gt;, an asymmetric multi-agent architecture that replaces monolithic assistants with an eight-seat programmatic council where roles (orchestration, generation, adversarial breaking, validation) are strictly segregated across five distinct models from four labs. Unlike prompt-based guidelines, critical invariants — a green build and a trusted test run before hand-over, test runs whose exit code cannot be masked by the shell, and decisions accepted only from the operator's recorded provenance — are enforced programmatically by the execution harness. We report a 17-day field deployment on a production-grade Go publishing service (20,749 lines of implementation code, 16,802 lines of test code across 365 test functions): the events the harness recorded, the defects the council caught and missed, and the failure modes of our own enforcement rules. We report mechanisms and observed events, not comparative rates.&lt;/p&gt;

&lt;h2&gt;
  
  
  1. The problem with one model in a chat
&lt;/h2&gt;

&lt;p&gt;A coding assistant built on one model plays every role at once. It reads the task, decides what the task means, writes the code, writes the tests for that code, runs them, reads the result and reports success. Each step is reasonable on its own. Together they form a closed loop in which the same reasoning that produced a mistake is the only reasoning asked to find it.&lt;/p&gt;

&lt;p&gt;Three failures follow from that loop, and we saw all three before we built anything else.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Self-review.&lt;/strong&gt; A model asked to check code it has just written tends to confirm its own intent rather than test it. The test it writes encodes the same assumption as the code, so both pass together and fail together.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Drift.&lt;/strong&gt; Over a long task the working context fills with the model's own intermediate decisions. The original specification is still there, but it competes with dozens of later, more local choices. By the third hour the work is consistent with itself and only loosely consistent with what was asked.&lt;/p&gt;

&lt;p&gt;&lt;strong&gt;Invention.&lt;/strong&gt; When the specification is silent — a rate limit, a field name, a size cap — a model fills the gap with a plausible value and moves on. The value is then load-bearing: other code depends on it, tests assert it, and nobody remembers that it was never decided.&lt;/p&gt;

&lt;p&gt;None of these is a capability problem that a larger model removes. They are structural: they come from one agent holding every role. Our hypothesis was that separating the roles across different models, and moving the most important rules out of prompts and into the program, would remove the loop rather than ask the model to resist it.&lt;/p&gt;

&lt;h2&gt;
  
  
  2. Architecture of the council
&lt;/h2&gt;

&lt;h3&gt;
  
  
  2.1 Seats
&lt;/h3&gt;

&lt;p&gt;The council has eight seats.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Orchestrator&lt;/strong&gt; runs the process: it reads the task, keeps the plan, hands stages to the other seats and reports to the human operator.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Architect&lt;/strong&gt; writes the design documents for a stage: data model, interfaces, decisions and open questions.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Code&lt;/strong&gt; implements the stage and owns the build and the tests.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Breaker&lt;/strong&gt; attacks the result as an adversary would: it tries to prove that something is broken, insecure or unnecessary. It does not fix anything.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Skeptic&lt;/strong&gt; reads the Breaker's findings and tries to refute them against the code. Only findings that survive go further.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Reviewer&lt;/strong&gt; turns the confirmed findings into a fix plan, or declares the stage clean.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Validator&lt;/strong&gt; signs off a stage only with evidence for every acceptance criterion of the specification.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Curator&lt;/strong&gt; reads every stage while it runs and raises notes where the work drifts from the specification or from earlier decisions.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;The seats that attack, review and validate Code's work run on models from other labs than Code. The model behind any seat is a route in our model gateway, so it can be changed without changing the program — we changed three seats during the period this paper covers.&lt;/p&gt;

&lt;h3&gt;
  
  
  2.2 The meeting
&lt;/h3&gt;

&lt;p&gt;Before any code, the seats meet. Each answers the stage's questions independently in the first round, without seeing the others. Later rounds discuss only the points where answers differ. The meeting ends with decisions per item, dissenting opinions recorded, and a list of what tests must prove. A human approves the resulting plan; nothing runs before that approval.&lt;/p&gt;

&lt;p&gt;The independent first round matters more than the discussion. When models see each other's answers first, they converge on the first confident one. When they answer blind, disagreements surface, and disagreements are where the specification is ambiguous.&lt;/p&gt;

&lt;h3&gt;
  
  
  2.3 The human
&lt;/h3&gt;

&lt;p&gt;The operator is not a reviewer of last resort but a source of decisions. The program treats the operator's recorded decisions — in the task specification or in the correspondence log — as the only authority for anything the specification does not state. A model may not write "per the operator's decision" unless such a record exists (§3.3).&lt;/p&gt;

&lt;h2&gt;
  
  
  3. Rules the program enforces
&lt;/h2&gt;

&lt;p&gt;A rule written in a prompt is a request. A rule written in the program is a fact. We moved four rules out of prompts.&lt;/p&gt;

&lt;h3&gt;
  
  
  3.1 Green before hand-over
&lt;/h3&gt;

&lt;p&gt;Code cannot hand over a stage until, after its last change of code, a build and a test run have both succeeded. The check is made by the program when the model calls the hand-over tool; a refused hand-over returns to the model with the reason.&lt;/p&gt;

&lt;h3&gt;
  
  
  3.2 Trusted runs
&lt;/h3&gt;

&lt;p&gt;Not every test run counts. A run whose exit code belongs to something other than the test runner — &lt;code&gt;make test | tail -40&lt;/code&gt;, &lt;code&gt;go test ./... || true&lt;/code&gt; — is recorded as untrusted, because the exit code is &lt;code&gt;tail&lt;/code&gt;'s or &lt;code&gt;true&lt;/code&gt;'s, not the tests'. A run that changes files, or ends on a signal, is untrusted too. Models write such commands constantly and in good faith; the program does not argue with them, it simply does not count the run.&lt;/p&gt;

&lt;h3&gt;
  
  
  3.3 Decisions only from the record
&lt;/h3&gt;

&lt;p&gt;When the model attributes something to the operator, the program looks for the decision in the task's specification or correspondence. A signature without a record does not stand. The same rule governs approval of the plan: the operator approves with a fixed phrase, optionally followed by a reason from a closed list of whole phrases. Anything else is treated as an amendment and the program asks again (§7.3 explains why the list is closed).&lt;/p&gt;

&lt;h3&gt;
  
  
  3.4 Notes need proof
&lt;/h3&gt;

&lt;p&gt;The Curator's notes are tracked in a ledger with statuses. A stage closes a note by answering it in its report — "done, where" or "disagree, why". A "done" is accepted only with proof: a change of code after the note was issued and a trusted green run after that change. A note about a missing document is closed by creating exactly that document. A change to the plan, the journal or the specification is never proof that code was fixed. Notes that stay open travel to the next stage and, in the end, to the Validator.&lt;/p&gt;

&lt;h2&gt;
  
  
  4. Parallel agents
&lt;/h2&gt;

&lt;p&gt;A seat can split its work across agents — short-lived workers with a narrow task and a clean context.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Read agents&lt;/strong&gt; (up to four per group) answer questions about the codebase: how a component is built, where a value comes from, what a test covers. They read; they cannot write.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Write agents&lt;/strong&gt; (up to four for Code, three for the Architect) each implement an independent part in a separate working copy. The program merges the parts back; a conflict stops the merge rather than being resolved silently.&lt;/li&gt;
&lt;/ul&gt;

&lt;p&gt;Agents do not replace the seats' judgment. They replace the seats' reading: a stage that would spend most of its context opening files gets short reports instead, and keeps its context for decisions. The operator sees the agents that are working right now and what each is doing.&lt;/p&gt;

&lt;h2&gt;
  
  
  5. The model gateway
&lt;/h2&gt;

&lt;p&gt;Every request from every seat and agent passes through our gateway. It routes a role to a model, enforces per-role budgets, and keeps the council working when a provider does not.&lt;/p&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;Budgets.&lt;/strong&gt; The smallest valid output budget a client sends wins; the gateway may lower it but never raise it. The ceiling is set by what fits inside the turn deadline, not by what the provider allows.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Spare models.&lt;/strong&gt; The seats on the busiest providers have a spare model from another lab. On a provider failure, a timeout, or when all of the provider's seats have been busy for more than 15 seconds, the request goes to the spare — before the first byte of the answer, never in the middle of a stream.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Circuit breaker.&lt;/strong&gt; After repeated provider failures the gateway stops calling that provider for a minute. Its own queue — seats busy with long turns — is never counted as a provider failure.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  6. Field study: a publishing service
&lt;/h2&gt;

&lt;p&gt;The codebase is a Go service that publishes content to social platforms on behalf of organisations: connections through each platform's OAuth, scheduled publishing, platform webhooks, per-platform limits and accounting of paid API calls. It was built by the council from an empty repository, with one human operator, between 11 and 27 October 2026. Every number below comes from the program's own logs — stage ledgers, test runs, the Curator's ledger and agent manifests — and from git.&lt;/p&gt;

&lt;h3&gt;
  
  
  6.1 Scale
&lt;/h3&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;&lt;/th&gt;
&lt;th&gt;End of step 1 (19 Oct)&lt;/th&gt;
&lt;th&gt;Now (27 Oct)&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Go code, lines (without tests)&lt;/td&gt;
&lt;td&gt;15,378&lt;/td&gt;
&lt;td&gt;20,749&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Test code, lines&lt;/td&gt;
&lt;td&gt;12,156&lt;/td&gt;
&lt;td&gt;16,802&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Test functions&lt;/td&gt;
&lt;td&gt;276&lt;/td&gt;
&lt;td&gt;365&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Packages&lt;/td&gt;
&lt;td&gt;—&lt;/td&gt;
&lt;td&gt;32&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Database migrations&lt;/td&gt;
&lt;td&gt;20&lt;/td&gt;
&lt;td&gt;23&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;&lt;em&gt;Note on test density:&lt;/em&gt; the test-to-code ratio is &lt;strong&gt;0.81&lt;/strong&gt; (16,802 lines of test code to 20,749 lines of implementation). We report it without a baseline: we have not compared it with human-written or single-model projects of similar scope.&lt;/p&gt;

&lt;h3&gt;
  
  
  6.2 Step 1: the full review cycle
&lt;/h3&gt;

&lt;p&gt;The first step built the core: organisations and access, connections, publishing, scheduling and operations. It closed with the complete cycle. The Breaker reported 17 findings — none critical, 5 high, 8 medium, 4 low — plus one hypothesis. The Skeptic confirmed all 17 against the code, refuted none, and lowered the severity of one. The Reviewer turned them into a 15-item fix plan; the operator added five mandatory items of his own. Two control rounds of the Breaker then went from 5 medium and 4 low findings to zero. The Validator signed off only after running the full test suite itself — 23 packages, exit code 0, no pipes — and attaching evidence to each of the 11 acceptance criteria. Its first attempt to sign off had been refused by the program: a verdict of PASS is not accepted unless the Validator ran the tests in its own stage.&lt;/p&gt;

&lt;h3&gt;
  
  
  6.3 Step 2: stages with timings
&lt;/h3&gt;

&lt;div class="table-wrapper-paragraph"&gt;&lt;table&gt;
&lt;thead&gt;
&lt;tr&gt;
&lt;th&gt;Stage&lt;/th&gt;
&lt;th&gt;Seat&lt;/th&gt;
&lt;th&gt;Duration&lt;/th&gt;
&lt;th&gt;Code lines added&lt;/th&gt;
&lt;th&gt;Test lines added&lt;/th&gt;
&lt;th&gt;Test functions&lt;/th&gt;
&lt;th&gt;Hand-over&lt;/th&gt;
&lt;/tr&gt;
&lt;/thead&gt;
&lt;tbody&gt;
&lt;tr&gt;
&lt;td&gt;Core of step 2: OAuth login, webhooks, streaming files, paid-call accounting, settings loader&lt;/td&gt;
&lt;td&gt;Code&lt;/td&gt;
&lt;td&gt;1 h 56 min&lt;/td&gt;
&lt;td&gt;2,992&lt;/td&gt;
&lt;td&gt;2,615&lt;/td&gt;
&lt;td&gt;46&lt;/td&gt;
&lt;td&gt;first attempt&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Telegram connector, plus the core's tail&lt;/td&gt;
&lt;td&gt;Code&lt;/td&gt;
&lt;td&gt;4 h 12 min, including operator pauses&lt;/td&gt;
&lt;td&gt;1,510&lt;/td&gt;
&lt;td&gt;1,388&lt;/td&gt;
&lt;td&gt;29&lt;/td&gt;
&lt;td&gt;first attempt&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Telegram: the operator's three decisions&lt;/td&gt;
&lt;td&gt;Code&lt;/td&gt;
&lt;td&gt;48 min&lt;/td&gt;
&lt;td&gt;827&lt;/td&gt;
&lt;td&gt;663&lt;/td&gt;
&lt;td&gt;14&lt;/td&gt;
&lt;td&gt;first attempt&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Bluesky: verification of the platform's documentation&lt;/td&gt;
&lt;td&gt;Code&lt;/td&gt;
&lt;td&gt;44 min&lt;/td&gt;
&lt;td&gt;0&lt;/td&gt;
&lt;td&gt;0&lt;/td&gt;
&lt;td&gt;0&lt;/td&gt;
&lt;td&gt;second attempt&lt;/td&gt;
&lt;/tr&gt;
&lt;tr&gt;
&lt;td&gt;Core gaps for all remaining platforms&lt;/td&gt;
&lt;td&gt;Architect&lt;/td&gt;
&lt;td&gt;58 min&lt;/td&gt;
&lt;td&gt;0&lt;/td&gt;
&lt;td&gt;0&lt;/td&gt;
&lt;td&gt;0&lt;/td&gt;
&lt;td&gt;with one open note&lt;/td&gt;
&lt;/tr&gt;
&lt;/tbody&gt;
&lt;/table&gt;&lt;/div&gt;

&lt;p&gt;Line counts come from the stage's working snapshots and exclude SQL migrations. Before the step, the council met on the architecture: four rounds, after which the operator took 13 decisions in one sitting.&lt;/p&gt;

&lt;h3&gt;
  
  
  6.4 What the program refused
&lt;/h3&gt;

&lt;p&gt;Across both steps the program refused a hand-over 37 times. In step 1, 36 refusals: 18 for attributing something to the operator without a recorded decision, 8 for open Curator notes, 6 for the absence of a green run, 2 for claiming documentation without a verbatim quote, one for a Breaker report that did not end with its findings line, and one for a Validator verdict without its own test run. In step 2, after we turned the Curator's notes and unrecorded signatures from blocks into remarks for the Validator, there was one refusal: the stage had decided its own exit code with &lt;code&gt;code=$?&lt;/code&gt; after the tests.&lt;/p&gt;

&lt;p&gt;The most frequent single event in the logs is not a refusal but a run that does not count. In step 2 the models ran tests 46 times; 42 of those runs were untrusted — piped into &lt;code&gt;tail&lt;/code&gt; (24), &lt;code&gt;grep&lt;/code&gt; (10) or &lt;code&gt;head&lt;/code&gt; (3), or followed by a command that set the exit code itself. The models were not hiding anything: piping long output is a habit. It is also exactly the habit that turns a red build green, which is why the program, not the model, decides what counts.&lt;/p&gt;

&lt;h3&gt;
  
  
  6.5 The Curator, before and after
&lt;/h3&gt;

&lt;p&gt;In step 1 the Curator issued 73 notes in one task; the stage refused hand-over seven times in under an hour while the count went 22, 20, 13, 11, 11, 12, 11; the operator switched the Curator off. That loop is §7.1. After the redesign, in step 2, the Curator ran 41 times across the stages, issued 9 notes — all of the kind "missed", none repeated, none without proof — and 8 were closed. Among them: a body-size limit invented in code without asking (closed by asking the operator), a stage handed over with no test files (closed by tests), Telegram limits without a quote from the platform's documentation (closed by quotes), and routes missing from the API description (closed by adding 39 paths and 50 operations).&lt;/p&gt;

&lt;h3&gt;
  
  
  6.6 Defects found without being asked
&lt;/h3&gt;

&lt;p&gt;Three times in step 2 a stage found and fixed a defect outside its task, proved it with a test and said so in its report. While building the core, Code found that one SQL parameter was used both as a UUID and as a timestamp, which made creating any connection fail with a server error. While building the Telegram connector, it found that an empty UUID was written instead of NULL, violating a foreign key and failing every incoming channel event. In the next stage it found the connector storing a sign-in token in the field meant for the platform's access token.&lt;/p&gt;

&lt;h3&gt;
  
  
  6.7 Stopping to ask
&lt;/h3&gt;

&lt;p&gt;The specification contains one sentence that shaped the work more than any other: &lt;em&gt;"What the task does not state as a number or a rule — do not invent it, ask me."&lt;/em&gt; The logs contain the questions it produced: the maximum size of a webhook body (asked mid-stage, answered in a minute and a half); how a Telegram channel is identified when the Bot API has no method to list a bot's channels; whether to apply the documented "about 30 messages per second". The most consequential came on Bluesky: its OAuth requires a DPoP key on every request and a public client-metadata document, and the core stored neither. Code stopped, named the exact lines where the core fell short and offered four options. The operator chose a separate Architect stage to find the core's gaps for every remaining platform at once.&lt;/p&gt;

&lt;h3&gt;
  
  
  6.8 Agents
&lt;/h3&gt;

&lt;p&gt;Agents ran seven times: six groups of read agents and one group of write agents, 22 agents in total. Fifteen returned reports. Four failed — the first group ever run in production, on the provider defect described in §7.2. Three were stopped by the operator, who narrowed the stage while they were reading. The single write group split the Architect's document into two parts written in parallel in three and a half minutes; the program could not merge them automatically, because fewer than 80% of their lines matched what the stage expected, and the Architect assembled them itself. Write agents for code have not yet run on this project.&lt;/p&gt;

&lt;h2&gt;
  
  
  7. What broke, and what we learned
&lt;/h2&gt;

&lt;h3&gt;
  
  
  7.1 The reviewer that kept saying the same thing
&lt;/h3&gt;

&lt;p&gt;The Curator kept raising the same note in slightly different words, and stages looped on it. The model was not the problem: we fed it only the number and title of its earlier notes — no status, no answer — and it could not see deleted lines, so a fix that removed code looked like no change. Giving it the full ledger and real diffs fixed the loop; duplicate detection then created the opposite bug ("migration 0019 not applied" and "migration 0020 not applied" merged into one). Similarity on headlines is not enough: numbers, identifiers and paths must tell notes apart, and anything only &lt;em&gt;probably&lt;/em&gt; a repeat goes to the human once.&lt;/p&gt;

&lt;h3&gt;
  
  
  7.2 The thinking model that rejected its own agents
&lt;/h3&gt;

&lt;p&gt;The first time agents ran in production, every agent died on its second request: the provider demanded its own reasoning back. The difference from the main loop was one line — the main loop always appends environment details after tool results, so the model sees a new turn; the agent loop did not. We had a test for exactly this request shape, and it had locked in the broken shape because it ran against mocks. Every release now runs the agents live on every model the seats use.&lt;/p&gt;

&lt;h3&gt;
  
  
  7.3 "I approve the plan, but…"
&lt;/h3&gt;

&lt;p&gt;We accepted the approval phrase followed by an explanation. Five review rounds of an attacker model kept finding phrasings that smuggled an amendment through — "because ok with Redis instead of Postgres". Any open vocabulary can be assembled into an amendment. The version that held: a closed list of whole phrases; anything else is an amendment.&lt;/p&gt;

&lt;h3&gt;
  
  
  7.4 Our proof rule had a ceiling
&lt;/h3&gt;

&lt;p&gt;Our first rule for closing a Curator note accepted any edit after the note plus a green run. An edit to the plan counted. The second version counted only code — but "named in the note" let a mention of the plan back in. The version that held is the one in §3.4, and it took five rounds of adversarial review. Even now the rule has a ceiling we accepted deliberately: one change of code and one trusted run can close several notes at once. Tying proof to the exact place of each note is the next step.&lt;/p&gt;

&lt;h3&gt;
  
  
  7.5 A rule's refusal is not the operator's
&lt;/h3&gt;

&lt;p&gt;When the program refused a command because the operator's own deny-list matched it, the model was told "the user denied this operation" — wording inherited from the editor we built on. The model reported that the operator had refused, which was false, and avoided the command for the rest of the stage. A refusal by rule now says which rule and what to do.&lt;/p&gt;

&lt;h2&gt;
  
  
  8. Limitations and threats to validity
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;
&lt;strong&gt;No benchmark.&lt;/strong&gt; We report a field study on one production codebase, not a benchmark. We have not measured the council against single-model assistants on a shared corpus; claims here are about mechanisms and observed events, not rates.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;One operator.&lt;/strong&gt; All stages had the same human operator, who also designed the process. A less involved operator would approve faster and catch less.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Small sample.&lt;/strong&gt; Seventeen days and one project. Several of the failures in §7 appeared once, and write agents for code have not run yet.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Model churn.&lt;/strong&gt; Three seats changed models during the period. We do not attribute outcomes to specific models.&lt;/li&gt;
&lt;li&gt;
&lt;strong&gt;Self-reporting.&lt;/strong&gt; The authors built the system they evaluate. Every number here comes from logs we can share on request.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  9. Artifact Availability and Evaluation Access
&lt;/h2&gt;

&lt;p&gt;α-Coder is deployed as an active web environment and VS Code extension. Researchers, developers, and system architects interested in stress-testing this multi-agent council architecture can access the platform at &lt;code&gt;ai-studio.alfa-can.com/alfa-coder&lt;/code&gt; (10 free testing hours available). We actively encourage blunt feedback regarding architectural edge cases, failure modes, and operational friction.&lt;/p&gt;

</description>
      <category>ai</category>
      <category>webdev</category>
      <category>programming</category>
      <category>devtool</category>
    </item>
    <item>
      <title>What broke when we made eight AI models work as one dev team</title>
      <dc:creator> Alfacan Defence Group</dc:creator>
      <pubDate>Mon, 26 Oct 2026 20:58:35 +0000</pubDate>
      <link>https://dev.to/development_dd8b958198d40/what-broke-when-we-made-eight-ai-models-work-as-one-dev-team-32e3</link>
      <guid>https://dev.to/development_dd8b958198d40/what-broke-when-we-made-eight-ai-models-work-as-one-dev-team-32e3</guid>
      <description>&lt;p&gt;&lt;a href="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Frur8zhamr9t20m7pag3c.jpg" class="article-body-image-wrapper"&gt;&lt;img src="https://media2.dev.to/dynamic/image/width=800%2Cheight=%2Cfit=scale-down%2Cgravity=auto%2Cformat=auto/https%3A%2F%2Fdev-to-uploads.s3.us-east-2.amazonaws.com%2Fuploads%2Farticles%2Frur8zhamr9t20m7pag3c.jpg" alt=" " width="800" height="533"&gt;&lt;/a&gt;&lt;/p&gt;

&lt;p&gt;&lt;em&gt;AlfaCan Defence Group — the team behind Alfa-Coder&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;Most AI coding tools are one model in a chat. For the past months we've been building something else: a small engineering team where every seat is an AI model, and no seat is allowed to check its own work.&lt;/p&gt;

&lt;p&gt;An Architect writes the design. Code implements it, splitting the work across parallel agents. A Breaker attacks the result like an adversary. A Skeptic checks which of the Breaker's findings are real. A Reviewer turns the confirmed ones into a fix plan. A Validator signs off only with evidence for every acceptance criterion. A Curator watches every stage for drift from the spec. Each seat runs on a model from a different lab. Before any code, the seats hold a meeting: each answers independently, they argue only where they disagree, and a human approves the plan.&lt;/p&gt;

&lt;p&gt;One rule matters more than the rest, and the program enforces it, not a prompt: Code cannot hand over a stage until the build is green and the tests pass.&lt;/p&gt;

&lt;p&gt;This week it built an OAuth and webhook core for a publishing service — about 3,000 lines of code and 2,600 lines of tests, 46 test functions, in under two hours, and fixed four bugs nobody had asked it to look for, including an SQL type error that would have returned a 500 on every new connection.&lt;/p&gt;

&lt;p&gt;Getting there broke in ways we didn't expect. Here are the ones worth sharing.&lt;/p&gt;

&lt;h2&gt;
  
  
  1. The reviewer that kept saying the same thing
&lt;/h2&gt;

&lt;p&gt;The Curator reads each stage's work and raises notes: "requirement X is not met", "this number isn't in the spec". It kept raising the same note again and again in slightly different words, and the stage looped on it.&lt;/p&gt;

&lt;p&gt;The model wasn't the problem. We were feeding it only the number and title of its last 40 notes — no status, no answer from the stage, no objection. It honestly didn't know the note had been fixed. It also had no way to see deleted lines, so a fix that removed code looked like no change at all.&lt;/p&gt;

&lt;p&gt;We gave it the full history of its notes, with statuses and answers, and real diffs with removed lines. Then we added duplicate detection: a note in other words is not a new note, and one note gets at most two rounds.&lt;/p&gt;

&lt;p&gt;That fix created the opposite bug. "Migration 0019 is not applied" and "Migration 0020 is not applied" now looked like the same note, and the second one disappeared silently. So did "no tests for the payment block" versus "no tests for the delivery block". Similarity on headlines is not enough: numbers, identifiers, paths and HTTP methods have to tell notes apart, and anything that is only &lt;em&gt;probably&lt;/em&gt; a repeat must never be dropped silently. It goes to the human once, as one question at hand-over: "these look like earlier notes — give them to the stage, or take them off?"&lt;/p&gt;

&lt;p&gt;It took four rounds of adversarial review on that one module before nothing slipped through in either direction.&lt;/p&gt;

&lt;h2&gt;
  
  
  2. The thinking model that rejected its own agents
&lt;/h2&gt;

&lt;p&gt;Code runs parallel agents for reading and writing. The first time we turned them on in production, every agent died on its second request with HTTP 400: &lt;em&gt;"The reasoning_content in the thinking mode must be passed back to the API."&lt;/em&gt;&lt;/p&gt;

&lt;p&gt;The main Code seat worked fine against the same model. The difference turned out to be one line. After tool results, the main loop always appends a block of environment details — so to the model, the next request is a new turn. The agent loop sent the tool results and nothing else, so the model treated it as the continuation of its own turn and wanted its reasoning back.&lt;/p&gt;

&lt;p&gt;We checked it against the live API in two requests: without a trailing line, 400; with one, 200. The fix is a short "Step N of M" line after tool results, and keeping the reasoning in the agent's turn for providers that need it back.&lt;/p&gt;

&lt;p&gt;The uncomfortable part: we had a test for exactly this request shape, and it locked in the broken shape, because it ran against mocks. Now every release runs the agents live on every model the seats use before it ships.&lt;/p&gt;

&lt;h2&gt;
  
  
  3. "I approve the plan, but…"
&lt;/h2&gt;

&lt;p&gt;The human approves the plan with a fixed phrase. People write more than the phrase, so we accepted the phrase plus an explanation. That opened a hole: &lt;em&gt;"I approve the plan, because it looks fine, but do stage 2 on Redis"&lt;/em&gt; counted as an approval, and the amendment was lost.&lt;/p&gt;

&lt;p&gt;We spent five review rounds on a list of words that mark an amendment — "but", "only", "instead", "later" and so on. Every round, the reviewer found a new phrasing that got through: &lt;em&gt;"because ok with Redis instead of Postgres"&lt;/em&gt;, &lt;em&gt;"because tests on the client"&lt;/em&gt;, &lt;em&gt;"because ok (stage 2 on Redis)"&lt;/em&gt;. Any open vocabulary can be assembled into an amendment.&lt;/p&gt;

&lt;p&gt;The version that held: after the approval phrase, only a short reason from a closed list of whole phrases counts — "all good", "the plan is clear", "no issues", "it's urgent". Anything else is an amendment, and the program asks again. A false approval launches work nobody asked for; an extra question costs one reply.&lt;/p&gt;

&lt;h2&gt;
  
  
  4. Our own gateway was spending 30× what the client asked
&lt;/h2&gt;

&lt;p&gt;A gateway sits between the editor and the model providers. It capped every answer at 32,768 tokens and filled the cap in when a request didn't set one. When we raised the cap, an adversarial review found that the gateway was rewriting budgets the client &lt;em&gt;had&lt;/em&gt; set: the Curator asks for at most 4,096 tokens, and the provider received 131,072. On a looping model, that is thirty times the intended cost and time.&lt;/p&gt;

&lt;p&gt;Rule we now enforce: the smallest valid budget the client sent wins, the cap only lowers it, and the cap is filled in only when the client set nothing.&lt;/p&gt;

&lt;p&gt;The same review caught that a 131,072-token answer can't finish inside a 25-minute turn at roughly 45 tokens a second. The turn would end in a cut-off stream and a fully paid failure. The real maximum is what fits in the deadline.&lt;/p&gt;

&lt;h2&gt;
  
  
  5. When a provider goes down for an hour
&lt;/h2&gt;

&lt;p&gt;One afternoon a provider started answering 500 to everything for about an hour, and the seat running on it stopped. So each external model now has a spare: on a provider failure, or when all its seats are busy for more than 15 seconds, the request goes to a model from another lab — before the first byte of the answer, never in the middle of a stream.&lt;/p&gt;

&lt;p&gt;The first version of the circuit breaker that stops hammering a dead provider had its own bug: it counted &lt;em&gt;our&lt;/em&gt; queue — seats busy with long turns — as a provider failure. At peak load it would have sent everything to the spare while the main model sat idle, halving throughput. Our own load is not their outage.&lt;/p&gt;

&lt;h2&gt;
  
  
  What we took from it
&lt;/h2&gt;

&lt;ul&gt;
&lt;li&gt;Most of the bugs were not in the models. They were in what we showed the models, and in how we read their answers.&lt;/li&gt;
&lt;li&gt;Every fix to a fuzzy rule created a new edge, so each one went through an adversarial cycle: an attacker model, a skeptic model, fixes, and a control round, until a round found nothing serious.&lt;/li&gt;
&lt;li&gt;Tests against mocks prove the code matches our assumptions about a provider, not the provider. Probe live.&lt;/li&gt;
&lt;/ul&gt;

&lt;h2&gt;
  
  
  Try it
&lt;/h2&gt;

&lt;p&gt;Alfa-Coder runs as a VS Code extension or in a browser workspace. You pay for working hours, not tokens, and time spent waiting on a model provider isn't billed.&lt;/p&gt;

&lt;p&gt;We're looking for developers to break it. There are 10 free hours: register at &lt;a href="https://ai-studio.alfa-can.com/alfa-coder" rel="noopener noreferrer"&gt;https://ai-studio.alfa-can.com/alfa-coder&lt;/a&gt; and press the test button on your dashboard. We'd value blunt feedback — what broke, what annoyed you, what you'd never use. We'll be in the comments.&lt;/p&gt;

</description>
      <category>llm</category>
      <category>ai</category>
      <category>devtools</category>
      <category>testing</category>
    </item>
  </channel>
</rss>
