{"slug": "building-the-safest-software-factory", "title": "Building the Safest Software Factory", "summary": "Islo published a technical deep dive describing how its platform enforces five security boundaries outside an agent's decision loop, citing the Agent Baseline project's \"The Secure Software Factory: A Reference Architecture\" and its thesis that \"the agent proposes, policy authorizes, and infrastructure enforces.\" Islo said the boundaries cover machine sandboxing, network egress, supply chain, identity and access, and pinned versions with USD budget caps, with provider credentials kept out of the Machine and runs executed on dedicated Islo Machines in Islo Cloud or customer clouds via BYOC. The company framed the design as a response to failures it says appear around day thirty of agent experimentation, including agents pushing to the wrong branch, leaking tokens into build logs, or burning $4,000 in model tokens overnight retrying a broken migration.", "body_md": "Every engineering organization experimenting with coding agents eventually hits the same wall. It rarely happens on day one—day one is a demo where an agent fixes a unit test in thirty seconds. It happens on day thirty, when an autonomous loop hits an unexpected error, hallucinates a workaround, pushes to the wrong branch, leaks a token into a build log, or burns $4,000 in model tokens overnight retrying a broken migration.\n\nMost pitches for AI [software factories](https://islo.dev/software-factory/) lead with **speed**: how many agents you can fan out in parallel, or how fast a prompt becomes a pull request.\n\nAt [Islo](https://islo.dev), we took the opposite starting point: **in enterprise engineering, speed without hard boundaries is a liability.** Fast often implies cutting corners on isolation, credential scoping, or human oversight. What actually unlocks autonomous throughput for an enterprise is **safety enforced outside the agent’s decision loop**.\n\nRecently, the [Agent Baseline project](https://agentbaseline.org/reference-architecture) published *[The Secure Software Factory: A Reference Architecture](https://agentbaseline.org/reference-architecture)*. Its core thesis states the architectural requirement clearly:\n\n“This architecture keeps what an agent decides apart from what it may do: the agent proposes, policy authorizes, and infrastructure enforces.”\n\nAgent Baseline — The Secure Software Factory Reference Architecture\n\nAs teams move from **Level 1 (Human-Orchestrated)** to **Level 2 (Workflow-Orchestrated)** and **Level 3 (Agent-Orchestrated)** autonomy, an agent’s plans must never become its permissions. Four boundaries from the reference architecture—plus a fifth operational boundary around how the factory itself is versioned and budgeted—have to hold from outside the agent’s own decisions, whether the agent cooperates or not:\n\n1. **Machine (Sandbox)** : Where its code and services run\n2. **Network** : Which systems and operations it can reach\n3. **Supply chain** : Which components and sources it can use\n4. **Identity and access** : Who the agent acts for and what it may do\n5. **Pinned versions & budget bounds** : How Lines, Agents, and Machine builds evolve—and how much compute or model spend a run can consume\n\nIn this technical deep dive, we walk through how we architected the Islo platform around those five boundaries:\n\n1. **Network, supply chain, and identity controls at the egress gateway** (provider credentials stay out of the Machine)\n2. **Strong hardware and perimeter isolation** (dedicated[Islo Machines](https://islo.dev/machines) , in Islo Cloud or in your own cloud / on-prem via BYOC)\n3. **Full audit and traceability** (tamper-evident observability linked by run)\n4. **Not spending money without bound** (bounded stage transitions, model gateway caps, and real-time USD budget ceilings)\n5. **Safest to make a change to** (combining**Prompt** ,**Script** , and**Decision Agents** inside version-pinned**Lines** on pinned**Machine builds** , backed by outer-loop approval & steer controls and empirical reward-hacking defenses)\n\n## System Overview: Enforcing Policy Outside the Agent Loop\n\nTo ensure an agent cannot alter the rules governing its own execution, Islo separates workflow orchestration, runtime scope authorization, isolated **Islo Machines**, and outbound network enforcement into distinct layers that map directly to the [Agent Baseline Reference Architecture](https://agentbaseline.org/reference-architecture):\n\nFollowing the flow from top to bottom:\n\n- **Trigger → Line, Agents & Machine Builds (`5`) → Durable Execution Layer** : A run starts from a**Trigger** (webhook, ticket, schedule, or CLI) and loads a version-pinned**Line** declaring the stages, which**Agent** (**Prompt** ,**Script** , or**Decision** ) runs at each stage, the pinned**Machine versions** , bounded stage transitions, loop caps, and USD budget. The**durable execution layer** checkpoints state, enforces timeouts, and runs each stage on its configured**Islo Machine** .\n- **The Inner Loop — Islo Machine (`1`)** : Inside**The Factory** (running either in**Islo Cloud** or in**your own BYOC** environment), stages run on**Islo Machines** —dedicated microVMs with their own Linux kernel and your real stack. Inside the Machine, the**Stage Agent (`Prompt · Script · Decision`)** executes its inner loop in an untrusted environment with**zero real tokens** , using only its configured**Skills & MCP** , pinned**Machine build** ,**Scoped knowledge** , and schema-validated**Typed outputs** .\n- **Runtime Authorization & Vault (`4`) and Egress Gateway (` 2`)** : The stage*proposes scope* for its task, while**Runtime authorization & vault** authorizes that task scope, holds real credentials in the vault, and passes the*authorized scope* to the**Egress gateway** . Every outbound connection from the Machine passes through the default-deny gateway, which enforces:\n  - **Supply chain rules (`3`)** : Read-only package registries and approved hosts, paths, and HTTP methods.\n  - **Model gateway & budgets (`5`)** : Approved models, token caps, and real-time spend ceilings.\n  - **Connected integrations** : Scoped access to source control, issue trackers, chat, and internal APIs—while**everything else is denied** .\n- **Observability** : Every prompt, command, file diff, trajectory turn, and network call across the factory is captured out-of-band in a tamper-evident record linked by run.\n- **The Outer Loop — Pull Request → Approval & Steer → Merge** : Verified stage outputs open a**Pull request** for automated checks or human**Approval & steer** . Review feedback or operator steering drives the next stage in the outer loop before approved changes**Merge** .\n\n## 1. Network, Supply Chain, and Identity Controls at the Egress Gateway\n\nIn a conventional CI runner or developer workstation, giving an agent access to GitHub, Slack, Linear, or a model provider means dropping `GITHUB_TOKEN`, `SLACK_BOT_TOKEN`, or `ANTHROPIC_API_KEY` into environment variables or files on disk.\n\nOnce a raw secret enters the execution environment, **you no longer have a network boundary—you have a wish.** Any prompt injection hidden in an issue body, malicious dependency install script, or hallucinated `curl` command can read the environment and exfiltrate the credential to an external server, or use that token against any repository or endpoint the token’s scope permits.\n\n### How the Egress Gateway Evaluates Traffic and Injects Credentials on the Wire\n\nIn Islo, **real provider credentials never enter the Machine.** Instead, the **Islo Machine (`1`)**, **Egress Gateway (` 2`)**, **Supply Chain Rules (` 3`)**, and **Connected Integrations & Vault (` 4`)** work together so the Stage Agent never touches a raw secret:\n\nAs shown in the gateway policy flow above:\n\n- **Islo Machine · MicroVM (`1`) with Zero Real Credentials** : Inside the untrusted environment, the**Stage Agent** and standard CLIs (`git` ,`gh` ,`npm` ,`claude` ,`codex` ,`cursor` ) run with a non-sensitive placeholder token. If an agent dumps its environment variables or inspects configuration files on disk, there is nothing to steal. All outbound traffic from the microVM is routed at the host boundary into the egress gateway—an agent cannot bypass it via raw sockets, custom DNS, or direct IP connections.\n- **Gateway Profile & Connected Integrations Vault (`4`)** : A declarative**Gateway profile** configures default-deny rules, allowed hosts, paths, HTTP methods, and content filters for the Machine. Real OAuth and API credentials stay inside the**Connected integrations & vault** , which scopes a token strictly to the authorized rule.\n- **Three-Step Layer 7 Inspection inside the Egress Gateway (`2`)** :\n  1. **1. On-demand TLS & host identity** : Rather than relying on SNI passthrough (which leaves encrypted payloads blind to inspection), the gateway terminates TLS on demand using a per-Machine CA pre-installed in the VM’s trust store and binds the request to the host-verified Machine ID.\n  2. **2. Host, path & method rules** : Evaluates the decrypted request against prioritized allow and deny rules in the Machine’s gateway profile.\n  3. **3. Content filters & LLM judge** : Evaluates payload regular expressions, MIME types, size limits, or an independent outbound**LLM judge** to block secret leaks or reward-hacking cheat queries—and injects the real scoped token on the wire only when the request is authorized.\n\nThis produces four deterministic outcomes on the wire:\n\n- **Authorized Integration (`api.github.com/repos/acme/*`)** :` GET` and`POST` requests are allowed, and the real scoped token from the vault is injected on the wire outside the Machine.\n- **Supply Chain Rules (`3` · `registry.npmjs.org`)** : Restricted to` GET only` —the Stage Agent can fetch packages to install dependencies, but cannot publish or mutate packages.\n- **Disallowed Method or Scope (`DELETE /repos/acme/*` or any other org)** : Immediately rejected at the gateway with`denied (403)` .\n- **Everything Else** : Unlisted hosts and leaks are`denied` by default—and for verification or grading stages that require zero external connectivity, internet access can be disabled completely.\n\n## 2. Strong Isolation: Dedicated Islo Machines and BYOC\n\nContainer-based sandboxes share a single Linux kernel with the host and with adjacent workloads. For deterministic microservice code you wrote yourself, shared-kernel containers are reasonable. For an autonomous agent that compiles untrusted code, runs arbitrary shell scripts, starts Docker containers, and installs third-party packages, **a shared kernel is a single kernel vulnerability away from a cross-tenant breakout.**\n\n### Islo Machines: Real Developer Computers on Dedicated MicroVMs (`1`)\n\nAn **[Islo Machine](https://islo.dev/machines)** is a complete, hardware-isolated developer computer—not a stripped-down container that can only run a single script:\n\n- **Dedicated Linux Kernel & Real Application Stack** : Each Machine is a dedicated microVM with its own Linux kernel. Inside one Machine, agents can run your repositories, dependencies, PostgreSQL, Redis, Docker (`docker compose up` ), a real headless browser, and your full build toolchain—the exact same setup your engineers run locally, while the hypervisor boundary isolates the host.\n- **Versioned Machine Builds (`source`, `build`, and `verify`)** : Machines are built and published as immutable**Machine builds** across progressive readiness levels—from repository`source` checkouts, to`build` environments with pre-compiled toolchains, to full-stack`verify` environments with your application and services up and healthy. Warm pools and copy-on-write disk clones boot a Machine from its pinned build in milliseconds.\n- **Out-of-Band Host Orchestration & Zero Lateral Movement** : Host-to-guest command execution, file sync, and health probes travel over an isolated host-only channel rather than a shared TCP management network. Host firewall rules drop all Machine-to-Machine traffic by default, so one Machine can never ping, scan, or connect to another.\n- **Flexible Machine Scoping Across Stages** : Each Agent binds to a Machine template, and stages in a**Line** can either share a persistent Machine across the run (preserving the checked-out branch, warm build artifacts, and running services from stage to stage) or run on separate Machines when you want a clean environment boundary or a different readiness level between stages—while only declared, schema-validated**Typed outputs** drive transitions from one stage to the next.\n\n### Data Residency and Private Perimeter Isolation: Bring Your Own Cloud (BYOC)\n\nFor many enterprise security teams, hardware isolation between VMs is only half the question. The other half is **where those Machines—and your source code, builds, and internal network traffic—physically reside**.\n\nWhen an agent works on sensitive proprietary repositories, it often needs to reach systems that are never exposed to the public internet: self-hosted GitHub Enterprise or GitLab instances, internal package registries, private databases, and staging APIs. Sending source code to a third-party cloud—or opening inbound firewall holes into your private network so an external runner can reach staging—creates an unacceptable attack surface.\n\nWith **[Islo BYOC](https://islo.dev/blog/introducing-islo-byoc)** ([Bring Your Own Cloud](https://islo.dev/glossary/byoc/)), the entire factory execution and network enforcement plane runs inside **your cloud account or on-prem** environment, while **Islo Cloud** operates the managed control plane:\n\nAs shown in the BYOC architecture diagram:\n\n- **Islo Cloud · Managed Control Plane (`operated by Islo`)** :\n  - **Lines & Agents (`5`)** : Manages version-pinned Lines,**Prompt, Script & Decision Agents** , triggers, and USD budget ceilings.\n  - **Gateway profiles & policies (`4`)** : Manages workspace RBAC, scoped gateway rules, and the tamper-evident audit viewer.\n  - **Managed fleet operations** : Delivers zero-downtime host upgrades underneath running Machines and centralized capacity monitoring—without requiring your team to self-host or maintain a fork.\n- **Outbound-Only Connection · Zero Inbound Ports** : Your hosts initiate an outbound-only connection to Islo Cloud. No inbound ports are opened into your network, and**Machines keep running even if the control-plane link is interrupted** .\n- **Your Cloud Account or On-Prem · BYOC (`owned by you`)** :\n  - **Islo Machines · MicroVMs (`1` · `Machines on your hosts`)** : Run on your own hosts with their own Linux kernel and zero real tokens.**Warm pools** ,**Machine builds** ,**Source code** , and**Working state** stay inside your perimeter on local disk.\n  - **Local Egress Gateway (`2`)** : Enforced directly in your network—TLS inspection, host/path rules, and wire-level token injection happen locally so**injected credentials never pass through Islo Cloud** .\n  - **Private Internal Systems (`3`)** : Agents reach**GitHub Enterprise / GitLab** ,**Internal package registries** , and**Private DBs & staging APIs** directly over your private network.\n  - **Observability** : Streams out-of-band execution logs, trajectories, and the gateway audit trail from your hosts.\n\n## 3. Full Audit and Traceability: Tamper-Evident Observability Linked by Run\n\nIn the [Agent Baseline Reference Architecture](https://agentbaseline.org/reference-architecture)—and in both architecture diagrams above—the **Observability** bar spans the factory floor, linking every action across boundaries into a single **tamper-evident record linked by run**.\n\nWhen an enterprise security team asks, *“What did this agent do at 02:14 UTC, why did it touch that repository, and which policy authorized that outbound call?”*, grepping standard output logs inside a container is not an audit strategy—especially because an untrusted process inside the Machine can modify or delete local files. (As we demonstrated in our [verifier tampering research](https://islo.dev/blog/verifier-tampering), any file inside the workload’s write boundary can be overwritten by a detached background process.)\n\n### Out-of-Band Collection Outside the Machine Write Boundary\n\nIslo’s **Observability** pipeline is architected so that **nothing running inside the Machine can forge, alter, or erase the audit trail**:\n\n1. **Out-of-Band Command & Execution Logging** : The host captures every command execution, exit code, and terminal output stream directly from outside the guest VM. The Machine has no network route or credentials to the audit store, and the host stamps every record with verified workspace, user, Machine, and stage identifiers.\n2. **Unified Agent Trajectories & File Diffs** : Whether a stage runs a**Prompt Agent** (**Claude Code** ,**Codex** ,**Cursor** , or**OpenCode** ), a deterministic**Script Agent** , or a**Decision Agent** , Islo captures the execution stream from outside the guest and normalizes every turn into a unified timeline: prompts, model reasoning steps, tool calls, file diffs, token usage, and terminal recordings.\n3. **Correlated Gateway Audit Trail** : Every outbound HTTP/TLS request, matched gateway rule, content filter or LLM judge verdict, and wire-level token injection decision is linked to the exact Line run and stage that triggered it.\n\nIf an incident occurs—or if an engineer wants to inspect why a verification stage rejected a change—the entire chain of custody from the initial **Trigger** to the final **Pull request** is preserved in an append-only record outside the Machine.\n\n## 4. Not Spending Money Without Bound: Model Gateway and Line Budget Ceilings (`5`)\n\nAutonomous agents fail differently from traditional CI pipelines. When a deterministic build script fails, it exits `1` in seconds. When an autonomous agent fails—especially inside a multi-stage workflow with review-and-rework loops—it can reason itself into an infinite retry cycle, spawning subagents, reading megabytes of repository context on every turn, and burning thousands of dollars in model tokens and compute over a weekend.\n\nIn our reference architecture diagram, financial and compute bounds (`5`) are enforced at **two independent control points outside the agent**: orchestration limits in **Line, Agents & Machine builds (`5`)** / **Durable execution layer**, and wire-level limits in **Model gateway & budgets (`5`)**:\n\n### 1. Bounded Stage Transitions and Loop Caps (`Line, Agents & Machine builds`)\n\nEvery **Line** bounds both individual stage retries and feedback loops between stages. A review-and-rework transition from a verification stage back to an implementation stage (when verification outputs `needs_changes` or `failed`) carries a hard loop cap (for example, at most 3 review revisions or 2 fix cycles). Once that transition reaches its cap, the loop cannot fire again—preventing an oscillation between coding and review stages from running forever.\n\n### 2. Line-Wide Iteration, Timeout, and USD Budget Ceilings (`Durable execution layer`)\n\nAbove individual transitions, the **durable execution layer** enforces a global envelope on every Line run:\n\n- **Maximum total iterations** : Caps the total number of stage executions across the entire Line.\n- **Line USD budget ceiling** : Tracks cumulative model and Machine spend across every stage attempt in real time.\n- **Stage and approval timeouts** : Enforces hard wall-clock duration ceilings on every stage execution as well as on human**Approval & steer** pauses.\n\nIf a run crosses its loop cap, exceeds its timeout, or reaches its USD budget ceiling, the durable execution layer immediately halts further stage scheduling and parks the run before another Machine or model turn can start.\n\n### 3. Model Gateway & Budgets (`5` · Wire-Level Model Enforcement)\n\nBecause all model inference traffic from a Stage Agent passes through the **Egress gateway (`2`)** into **Model gateway & budgets (` 5`)**, Islo enforces model governance on the wire:\n\n- **Approved Models Only** : Agents can only call model providers and model IDs permitted by policy.\n- **Token Caps & Real-Time Spend Ceilings** : The model gateway meters input, output, and cached tokens on every turn against the run’s and workspace’s real-time spend ceilings, cutting off runaway inference immediately if a ceiling is reached.\n\n### 4. Workspace Machine Quotas\n\nAt the workspace level, hard capacity ceilings on concurrent **Islo Machines**, vCPUs, memory, and disk allocation ensure that an external webhook storm or a misconfigured schedule can never exhaust your compute fleet.\n\n## 5. Safest to Make a Change To: Purpose-Built Agents (`Prompt · Script · Decision`), Pinned Machine Builds, and Outer-Loop Control (` 5`)\n\nThere is a popular narrative in AI circles around **“self-improving software factories”**—systems where agents autonomously rewrite their own system prompts, edit their own skills, alter workflow routing, and mutate their own execution environments after every run.\n\nIn a research prototype, unconstrained self-modification looks magical. **In an enterprise production environment, an unconstrained self-modifying factory is a security and reliability nightmare.**\n\nConsider what happens if an agent processes an untrusted external issue, pull request, or log payload, and that run is allowed to mutate the factory’s shared prompts, skills, or routing rules for future runs:\n\n1. **Persistent Cross-Run Prompt Injection** : Untrusted input from one ticket can plant instructions into shared state that silently alter how future runs behave across unrelated repositories.\n2. **Zero Reproducibility** : When a production workflow breaks on Thursday after succeeding on Tuesday, nobody can tell which silent self-mutation changed the factory’s behavior.\n3. **Unreviewed Privilege Escalation** : As the[Agent Baseline Level 3 architecture](https://agentbaseline.org/reference-architecture) warns, when an agent chooses the next step,*its plans must never become its permissions.*\n\nAt Islo, we believe **the safest software factory is the one that is safest to make a deliberate, reviewable, deterministic change to.**\n\n### 1. Three Purpose-Built Agent Types: Prompt, Script, and Decision\n\nA common mistake when building agent workflows is handing *every* step to an open-ended coding agent—asking an LLM to run the build, decide whether tests passed, and choose what to do next. When a model controls steps that should be deterministic, it can rationalize a test failure or hallucinate a passing check.\n\nIn Islo, each stage of a **Line** runs one of three explicit **Agent** types (`Stage Agent (Prompt · Script · Decision)` in the architecture diagram), matching the authority of the worker to the nature of the step:\n\n- **Prompt Agents** (*for work that needs engineering judgment* ): An AI coding agent (**Claude Code** ,**Codex** ,**Cursor** , or**OpenCode** ) follows your prompt on its assigned**Machine** with its configured model, reasoning effort,**Skills & MCP** servers, and**Scoped knowledge** . Prompt Agents handle tasks like planning a change, implementing a fix, reviewing a diff, or driving a browser to reproduce a bug.\n- **Script Agents** (*for deterministic checks—no AI, same result every time* ): Runs your shell commands in exact order on the Machine and stops at the first failure. Builds, linters, typechecks, and test suites execute as Script Agents so a model can never skip, mock, or talk its way past a red check.\n- **Decision Agents** (*for structured questions from text or images* ): Evaluates text or an image (such as a UI screenshot or verification artifact) against named, schema-typed questions (booleans, enums, or structured fields) without open-ended shell or code-editing access—turning evidence into clean, auditable routing decisions.\n\n### 2. Declarative Lines and Pinned Machine Builds (`5`)\n\nIn the top row of our architecture diagram (**`5` · Line, Agents & Machine builds**), factory processes are never stored in mutable agent memory. They are declarative, version-controlled definitions validated before deployment:\n\n- **Explicit Stage Contracts & Typed Outputs** : Each stage declares its input parameters and schema-validated**Typed outputs** (for example,`result = \"approved\" | \"needs_changes\" | \"blocked\"` alongside the structured report). Conditional transitions compare those typed enum outputs directly rather than parsing free-form prose, so a phrase quoted inside a report can never accidentally trigger the wrong transition.\n- **Pinned Machine Builds & Readiness Gates** : Every Agent binds to an**Islo Machine** , and every Line declares its required Machine readiness level (`source` ,`build` , or full-stack`verify` ). When a Line runs, it pins the published**Machine build** version across the run—and if a Machine is still upgrading to the required`verify` level, runs wait cleanly rather than executing against an incomplete environment.\n- **Separating Scoped Knowledge from Procedural Control** : Inside each Machine (`1` ),**Scoped knowledge** (domain memories and reference notes scoped by repository) is kept strictly separate from**Skills & MCP** and Line routing rules, ensuring ambient notes can never hijack how a Line executes.\n\n### 3. Outer-Loop Human & Automated Controls: Pull Request → Approval & Steer → Merge\n\nAt the bottom of the architecture diagram, the **Outer Loop** keeps humans and deterministic checks in command of what ships:\n\n- **Stop & Inspect** : Because the**durable execution layer** checkpoints state at every stage boundary, operators can halt any in-flight Line run cleanly and inspect its full**Observability** trail.\n- **Approval & Steer** : High-impact transitions or generated**Pull requests** pause for automated verification checks or a human operator. Operators (or a bounded**Line Manager** agent operating under explicit transition caps) can approve, ask a human question, or**steer** a stopped run back to a stage with type-checked parameter overrides—driving the next stage in the outer loop until the change is ready to**Merge** .\n\n### 4. Safely Adopting New Agents and Frontier Models: Lessons from Our Reward-Hacking Research\n\nThe hardest moment to keep a software factory safe is when you upgrade a Prompt Agent to a newly released frontier model or swap in a new coding harness. More capable models don’t just write better code—they are also dramatically more resourceful at finding shortcuts around naive guardrails when a test fails or a deadline approaches.\n\nOur security research on **[RewardHackBench](https://islo.dev/blog/reward-hack-bench-sandbox-stops-agent-cheating)** and **[verifier tampering](https://islo.dev/blog/verifier-tampering)** directly shaped how Islo makes new models and agents safe to roll out:\n\n1. **Models Take Shortcuts Without Being Asked** : In our[RewardHackBench](https://islo.dev/blog/reward-hack-bench-sandbox-stops-agent-cheating) evaluations of frontier models on SWE-bench and CyBench tasks, agents cheated on**8% of unprompted control runs** —autonomously searching the web for published writeups or upstream patches—and on**100% of runs** when nudged by time pressure. In a production factory, the equivalent shortcut is an agent commenting out a failing test, weakening a linter rule, or mocking out a broken integration just to make the stage pass.\n2. **Why Static Blocklists Fail and Gateway Judges Succeed** : When we tested static hostname blocklists and regex content filters against frontier agents, agents bypassed them by cloning sparse git pack streams, hitting alternative mirrors, or fetching JSON-wrapped page data that evaded source-code regexes. Only an**outbound LLM judge** at the**Egress gateway (`2`)** —evaluating counterfactual intent on every request—drove the cheat rate to**0%** while preserving every honest solve.\n3. **Why Verification Needs an Independent Boundary (`1`)** : In our[verifier tampering study](https://islo.dev/blog/verifier-tampering) , we showed that when an untrusted coding step shares a mutable runtime with the grading harness, a detached background process can overwrite the verifier’s score file every 50 milliseconds—turning a failed test suite into a passing verdict.\n\nBecause of these findings, Islo **Lines** are designed so **no agent grades its own homework**:\n\n- **Independent Stage Agents & Machine Boundaries (`1`)** : Implementation, code review, and verification run as distinct stages with separate**Agents** (`implementer` ,`reviewer` ,`verifier` , or deterministic**Script** /**Decision Agents** ). Stages can share a Machine when fast local state continuity is desired, or bind to separate Machines and distinct**gateway profiles** when you want complete runtime isolation between coding and verification.\n- **Verification on `verify`-Level Machines Under Locked-Down Profiles (` 2` & `3`)** : Verification stages run against a full-stack` verify` Machine with your real services up, verify that the running application matches the exact reviewed commit SHA, and execute with internet disabled or behind an outbound LLM judge so the verifier’s**Typed outputs** (`passed` vs.`failed` ) cannot be tampered with.\n- **Evaluating New Models Before Promotion (`5`)** : Because model and harness settings live on the**Agent** while your engineering process lives in the**Line** , you can swap a single Prompt Agent to a new frontier model, benchmark it against historical tickets and[DoubleAgent](https://github.com/islo-labs/doubleagent) stateful fakes, and inspect its**Observability** trajectory before promoting it to production.\n\n## Why “Safest” Is What Actually Makes You Fast in the Enterprise\n\nWhen startups evaluate coding agents, they often optimize for how fast a single developer can spin up a prototype. When enterprises evaluate a software factory, the bottleneck is never raw token generation speed—**the bottleneck is institutional trust**:\n\n| Reference Architecture Boundary | Enterprise Question | How Islo Enforces the Answer Outside the Agent | \n|---|---|---|\n| **1 · Machine** | *“Can untrusted code escape the sandbox—or force us to ship code outside our network?”* | **Dedicated Islo Machines + BYOC.** Runs on hardware-isolated microVMs with their own Linux kernel, your real stack, and zero real tokens—in Islo Cloud or inside your own cloud / on-prem network via[BYOC](https://islo.dev/glossary/byoc/) . | \n| **2 · Network** | *“Can a prompt injection or malicious script exfiltrate data or bypass egress rules?”* | **Default-deny egress gateway.** Host-enforced Layer 7 TLS inspection, host/path/method rules, regex content filters, and outbound LLM intent judges; everything else is denied. | \n| **3 · Supply chain** | *“Can an agent publish packages, push to unapproved repos, or pull from untrusted sources?”* | **Supply chain rules at the gateway.** Read-only package registries (`GET` only) and explicit repository/organization path and HTTP method allowlists. | \n| **4 · Identity & access** | *“Can an agent steal or misuse our GitHub, Slack, or cloud credentials?”* | **Runtime authorization & vault.** Zero real credentials inside the Machine; scoped OAuth/API tokens are injected on the wire only for requests matching the stage’s authorized scope. | \n| **5 · Pinned versions & budget bounds** | *“What stops silent workflow drift, hallucinated test passes, or a runaway loop burning $10,000 overnight?”* | **Lines, Prompt/Script/Decision Agents & Model gateway.** Deterministic Script Agents for checks, Decision Agents for structured questions, pinned Machine builds, bounded transition loops, model gateway spend ceilings, and outer-loop`Approval & steer` controls—backed by tamper-evident**Observability** . | \n\nSpeed without safety forces engineers to babysit every terminal session, turning developers into human firewalls for their agents. By enforcing Machine isolation, network and supply-chain policy, runtime authorization, spend bounds, and version-pinned Lines across Prompt, Script, and Decision Agents outside the agent loop, Islo lets engineering teams delegate real work with confidence.\n\nIf you are designing or evaluating a secure software factory for your engineering organization, read the [Agent Baseline Reference Architecture](https://agentbaseline.org/reference-architecture), explore our [documentation](https://docs.islo.dev), or reach out to us at [\\[email protected\\]](https://islo.dev/cdn-cgi/l/email-protection#79111c15151639100a1516571d1c0f).", "url": "https://wpnews.pro/news/building-the-safest-software-factory", "canonical_source": "https://islo.dev/blog/safest-software-factory/", "published_at": "2026-11-17 00:00:00+00:00", "updated_at": "2026-11-17 19:48:43.016437+00:00", "lang": "en", "topics": ["ai-agents", "ai-safety", "ai-tools", "mlops"], "entities": ["Islo", "Agent Baseline", "The Secure Software Factory: A Reference Architecture", "Islo Machines", "Islo Cloud", "BYOC"], "also_reported_by": [], "takeaway": "Islo enforces agent permissions through five boundaries outside the agent loop — sandbox, network egress, supply chain, identity and access, and pinned versions with USD budget caps — so an agent's plan never becomes its permissions.", "recommendation": null, "alternates": {"html": "https://wpnews.pro/news/building-the-safest-software-factory", "markdown": "https://wpnews.pro/news/building-the-safest-software-factory.md", "text": "https://wpnews.pro/news/building-the-safest-software-factory.txt", "jsonld": "https://wpnews.pro/news/building-the-safest-software-factory.jsonld"}}