# Secure cloud workspaces make AI coding agents enterprise-ready | LinearB Blog

> Ona’s Matt Boyle reveals how secure cloud workspaces are the missing link for enterprise AI, detailing how Project Veto’s kernel-level controls prevent agents from bypassing security and why the "run loop" is more important than code suggestion.

_This is a markdown rendering of a live HTML page on linearb.io, generated for AI/LLM consumption — it is not a markdown-only site. To get the full HTML page instead, request this URL with an explicit `Accept: text/html` header (no wildcard, no markdown preference)._


```json
{
  "@context": "https://schema.org",
  "@type": "BreadcrumbList",
  "itemListElement": [
    {
      "@type": "ListItem",
      "position": 1,
      "name": "Home",
      "item": "https://linearb.io/"
    },
    {
      "@type": "ListItem",
      "position": 2,
      "name": "Blog",
      "item": "https://linearb.io/blog"
    },
    {
      "@type": "ListItem",
      "position": 3,
      "name": "Secure cloud workspaces make AI coding agents enterprise-ready",
      "item": "https://linearb.io/blog/matt-boyle-ona-secure-workspaces-project-veto-ai-agents"
    }
  ]
}
```

[Home](https://linearb.io/)

/

[Blog](https://linearb.io/blog)

/

Secure cloud workspaces make AI coding agents enterprise-ready

# Secure cloud workspaces make AI coding agents enterprise-ready

![Photo of Andrew Zigler](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/Headshot3_d7231cbda7?_a=BAVMn6ID0)

By [Andrew Zigler](https://linearb.io/blog/matt-boyle-ona-secure-workspaces-project-veto-ai-agents#andrew-zigler)

|

April 22, 2026

![Blog_Secure_cloud_workspaces_2400x1256_b9665a5ebd](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/Blog_Secure_cloud_workspaces_2400x1256_b9665a5ebd?_a=BAVMn6ID0)

The arrival of AI coding agents has exposed a fundamental mismatch. These tools are operating in an internet designed for humans, not autonomous systems. While the conversation around agentic AI often centers on model capabilities, the real unlock lies in the surrounding infrastructure. This includes the development environments where agents execute, iterate, and deliver working software.

[Matt Boyle](https://linearb.io/dev-interrupted/podcast/matt-boyle-ona-secure-developer-environments-humans-agents), head of Product, Design, and Engineering at Ona (formerly Gitpod), is building exactly that infrastructure. His team is extending workspace technology into an enterprise AI engineering platform where ephemeral, secure, and pre-configured cloud environments become the foundation for safe, scalable agent adoption. The core insight is that the environment is still central to everything we do, making it arguably more important than the agent itself.

## Why secure cloud environments unlock enterprise AI coding

The evolution from Gitpod to Ona was not a pivot. It was an extension. Gitpod's original mission focused on eliminating friction for human developers, reducing time to first commit by turning complex enterprise setup into reproducible cloud environments. That same infrastructure, it turns out, makes agents more productive too. Boyle points out that any optimization designed to [make a human developer more efficient](https://linearb.io/resources/software-engineering-benchmarks-report) directly translates to agent productivity.

The key is context. Just as human developers benefit from access to internal documentation, code repositories, and execution feedback, agents thrive when given the same resources, but only when those resources are contained within the right environment. Ona's approach prioritizes running agents off the laptop in auditable, configurable cloud environments that support enterprise adoption and brownfield integration. This creates a controlled perimeter where agents can access private data, internal knowledge bases, and execution loops without exposing sensitive information beyond the organization's network.

What is emerging is usage beyond traditional software engineers. Adjacent technical personas like data scientists, business analysts, and citizen developers are finding value in browser-based tooling with policy-aware defaults and guided access. These users do not need a fully fledged IDE. They need an environment that works immediately and safely, without requiring deep configuration expertise.

## Ephemeral workspaces accelerate onboarding and contain risk

The original workspace value proposition was simple. Teams could encode best-practice setups once and then distribute them broadly. This allows an organization to use their best engineer to configure a cloud laptop setup that everyone else can seamlessly adopt.

For human developers, this meant reducing a 30-day onboarding process down to a single click. For agents, the stakes are even higher. Disposable, ephemeral environments provide controlled context, deterministic tooling, and private data access. All of these elements improve reliability without exposing sensitive information. Because these environments are ephemeral, they can be spun up, used, and torn down without leaving residual state or security vulnerabilities.

Enterprise deployment often happens inside customer VPCs, allowing workspace networking and policy controls to align with existing corporate security models. This approach addresses a critical trust requirement. Regulated industries and risk-averse organizations need [safe, configurable workspaces](https://linearb.io/blog/platform-engineering) before they will permit AI usage at scale. The environment becomes the security boundary rather than just the execution surface.

## Run loops turn agents into software delivery systems

The real unlock for AI coding is not code suggestion. It is the run loop. Agents become genuinely useful when they can execute tests, inspect failures, and iterate toward working changes. This shift moves AI from code review to end-to-end delivery, especially when paired with strong tests, documentation, and organizational context.

Boyle shared a concrete workflow where planning, design review, ticket generation, implementation, and [pull request creation](https://linearb.io/use-case/optimize-code-review) are chained together in a human-in-the-loop software development lifecycle. The process begins with a prompt that triggers planning mode. The agent explores the codebase, generates a design document, pushes it to Notion for review, incorporates feedback, creates a project with dependency-mapped tickets, and assigns parallelizable tasks to agents. By the end of the day, a feature that would have taken two weeks was shipped while Boyle was in meetings. He notes that this entire process is ultimately about bringing humans into the loop at exactly the right points.

This workflow illustrates a broader shift where development interfaces are moving away from traditional IDE-centric editing toward conversation, review, and orchestration surfaces accessible from browsers and phones. Boyle rarely opens a full IDE anymore. Instead, he raises pull requests instead of tickets, reviews agent-generated code in the product, and iterates through comments without ever leaving the platform.

The future evolution will feature a tension between longer autonomous loops and enterprise SDLC checkpoints. More autonomy is expected as models and operational controls improve, but compliance obligations and risk management currently require human oversight at critical decision points.

## Kernel-level controls stop agents from bypassing security

Application-level permissions are not enough for agents. Highly goal-driven systems will route around superficial restrictions when trying to complete a task. Boyle's team discovered this firsthand when observing agent behavior in restricted environments.

"One thing that agents do is, because they have such a strong reward function, they'll try and use curl, it will fail, and then they'll write a Python script which reimagines curl and makes the request that way because they're just so incentivized to achieve the outcome."

Agents will rename tools, recreate blocked functionality, or exfiltrate data if it helps them achieve their objective. To address this, Ona introduced Project Veto, a kernel and eBPF-based control system that inspects and stops risky behavior at runtime. These controls sit below the application layer, where agents cannot easily circumvent them.

This approach is part of a defense-in-depth agent security strategy that complements workspace isolation, network boundaries, and organizational policy configuration. The security model depends on owning more of the execution stack, including standardized virtual machines, images, and kernels, so enforcement remains consistent. Organizations can configure security policies based on their risk appetite, balancing recommended default rules with stricter enterprise-specific controls.

## Turning one prompt into coordinated delivery

Enterprise changes rarely live in a single repository. A front-end dashboard update might require changes to the API gateway, backend services, and Terraform configurations. Orchestrating these changes manually is tedious and error-prone, but agents are exceptionally well-suited to this coordination.

"There's absolutely no reason why a single prompt box couldn't drive changes across 10 repositories at once," Boyle explains.

Ona's primitives allow a single intent to drive coordinated changes across many repositories, with sequencing handled automatically. The platform extends orchestration beyond code generation to planning artifacts, integrating with documentation systems, issue trackers, and communication tools to move work from design through execution.

Tasks can be decomposed into small, parallelizable units, assigned based on dependency structure, and reassembled through review-ready pull requests. This orchestration model aligns with software factory thinking, where intent flows through a structured pipeline. Regulated organizations still need agent workflows to respect existing approval and compliance checkpoints, but one person can now simply outline the desired outcome while the human-agent team works toward that end state together.

This vision of collaborative orchestration represents a [fundamental shift in how software gets built](https://linearb.io/blog/how-agentic-ai-will-disrupt-your-software-delivery-lifecycle). The challenge ahead is balancing the speed of autonomous systems with the governance requirements of enterprise SDLC. For now, the environment remains the critical enabler, ensuring agents can operate safely, effectively, and at scale.

To hear more about secure cloud workspaces and enterprise AI, listen to Matt Boyle discuss these ideas in depth on the Dev Interrupted podcast. 

## Improve developer productivity with LinearB

Find us on

[](https://www.linkedin.com/company/linearb)
[](https://devinterrupted.substack.com/)

![Headshot3_d7231cbda7](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/Headshot3_d7231cbda7?_a=BAVMn6ID0)

## Andrew Zigler

Andrew Zigler is a GTM Engineer at LinearB and the host of Dev Interrupted, a twice-weekly podcast and newsletter where 40k+ builders decode the transition to AI-native development and agentic orchestration. A classicist by training with a degree from The University of Texas at Austin, Andrew spent his early career teaching in Japan before channeling his interdisciplinary instincts into the tech world. His polymath background informs everything he builds, from automated workflows to the stories he tells about the seismic shifts reshaping software creation.

### Connect with

[](https://www.linkedin.com/in/andrewzigler)
[](https://substack.com/@zigler)
[](https://x.com/andrewzigler)

## Your next read

[![Cover image for Rippling's employee graph turns HR data into an agentic AI platform](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/Blog_Post_Name_2400x1256_be5ec4183f?_a=BAVMn6ID0)](https://linearb.io/blog/rippling-albert-strasheim-employee-graph-agentic-ai)

AI

[Rippling's employee graph turns HR data into an agentic AI platform](https://linearb.io/blog/rippling-albert-strasheim-employee-graph-agentic-ai)

Rippling CTO Albert Strasheim explains why the employee graph serves as the essential context layer for enterprise agentic AI. Discover how unifying HR, IT,...

[![Cover image for Deterministic guardrails must evolve to control probabilistic AI systems](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/Blog_Post_Name_2400x1256_5_f5375661ec?_a=BAVMn6ID0)](https://linearb.io/blog/launchdarkly-cameron-etezadi-deterministic-guardrails-probabilistic-ai-darkfactory)

AI

[Deterministic guardrails must evolve to control probabilistic AI systems](https://linearb.io/blog/launchdarkly-cameron-etezadi-deterministic-guardrails-probabilistic-ai-darkfactory)

LaunchDarkly CTO Cameron Etezadi explains why traditional engineering pipelines are breaking down in a probabilistic, AI-driven world. Discover how to safely...

[![Cover image for Slack turns channels into the context engine for agentic AI](https://assets.linearb.io/image/upload/c_limit,w_2560/f_auto/q_auto/v1/Blog_Post_Name_2400x1256_077524ba8b?_a=BAVMn6ID0)](https://linearb.io/blog/slack-jaime-delanghe-mcp-agent-context-channels)

AI

[Slack turns channels into the context engine for agentic AI](https://linearb.io/blog/slack-jaime-delanghe-mcp-agent-context-channels)

Slack Chief Product Officer Jaime DeLanghe breaks down how channels serve as the foundational context layer for human-agent collaboration. Learn why Slack is...

## Structured data

_Machine-readable metadata (JSON-LD) embedded in the page for search/AI context — not content rendered on the page itself._

```json
{
  "@context": "https://schema.org",
  "@type": "Organization",
  "name": "LinearB",
  "url": "https://linearb.io/",
  "logo": "https://assets.linearb.io/image/upload/v1715628027/logo-mark-lg.svg",
  "description": "LinearB is the engineering productivity platform that helps engineering leaders prove AI is improving throughput without sacrificing delivery confidence, flow efficiency, or developer experience.",
  "sameAs": [
    "https://www.linkedin.com/company/linearb"
  ],
  "award": [
    {
      "@type": "Award",
      "name": "LinearB is a Leader in the 2026 Gartner® Magic Quadrant™ for Developer Productivity Insight Platforms",
      "dateAwarded": "2026",
      "awardedBy": {
        "@type": "Organization",
        "name": "Gartner®"
      }
    },
    {
      "@type": "Award",
      "name": "Great Place to Work Certification",
      "dateAwarded": "2025-2027",
      "awardedBy": {
        "@type": "Organization",
        "name": "Great Place to Work"
      }
    },
    {
      "@type": "Award",
      "name": "America's Best Startup Employers 2025",
      "dateAwarded": "2025",
      "awardedBy": {
        "@type": "Organization",
        "name": "Forbes Magazine"
      }
    }
  ],
  "hasCertification": [
    {
      "@type": "Certification",
      "name": "SOC 1 Type 2"
    },
    {
      "@type": "Certification",
      "name": "SOC 2 Type 2"
    },
    {
      "@type": "Certification",
      "name": "GDPR Compliance certification"
    },
    {
      "@type": "Certification",
      "name": "ISO 27001"
    }
  ]
}
```

```json
{
  "@context": "https://schema.org",
  "@type": "Article",
  "headline": "Secure cloud workspaces make AI coding agents enterprise-ready",
  "url": "https://linearb.io/blog/matt-boyle-ona-secure-workspaces-project-veto-ai-agents",
  "author": {
    "@type": "Person",
    "name": "Andrew Zigler"
  },
  "datePublished": "2026-04-22T07:00:00.000Z",
  "dateModified": "2026-04-22T07:00:00.000Z",
  "image": "https://assets.linearb.io/image/upload/v1776900676/Blog_Secure_cloud_workspaces_2400x1256_b9665a5ebd.png",
  "publisher": {
    "@type": "Organization",
    "name": "LinearB",
    "logo": "https://assets.linearb.io/image/upload/v1777485755/linearb-logo-2026.png"
  },
  "description": "Ona’s Matt Boyle reveals how secure cloud workspaces are the missing link for enterprise AI, detailing how Project Veto’s kernel-level controls prevent agents from bypassing security and why the \"run loop\" is more important than code suggestion."
}
```

## More on linearb.io

### Top navigation

- [Book a Demo](https://linearb.io/book-a-demo)
- [AI Code Reviews — Catch security risks, bugs, and spec mismatches](https://linearb.io/platform/ai-code-reviews)
- [AI & Productivity Insights — See how AI tools affect cycle time and delivery speed](https://linearb.io/platform/ai-developer-productivity-insights)
- [Measure AI Impact — Track AI adoption and tie it to delivery outcomes](https://linearb.io/use-case/measure-ai-impact)
- [MCP Server — Chat with your data to spot patterns and boost output](https://linearb.io/platform/mcp-server)
- [Resource Allocation — Cost initiatives and shape your investment strategy](https://linearb.io/platform/resource-allocation)
- [Cost Capitalization — Capitalize engineering costs with audit-ready reports](https://linearb.io/platform/cost-capitalization)
- [Dev Team Management — Set targets and tie throughput to business outcomes](https://linearb.io/platform/goals-and-reporting)
- [DevOps Workflow Automation — Policy-based PR routing, approvals, and tests](https://linearb.io/platform/ai-workflow-governance)
- [AI Powered Support — Unify AI and human code delivery in one clear view](https://linearb.io/use-case/ai-powered-support)
- [Optimization — Surface friction with feedback and MCP insights](https://linearb.io/platform/developer-experience)
- [Reporting — Spot what's working and what needs attention](https://linearb.io/use-case/measuring-developer-experience)
- [Surveys — Turn developer feedback into actionable signals](https://linearb.io/platform/developer-surveys)
- [Platform overview](https://linearb.io/platform/overview)
- [Register now](https://linearb.io/event/engineering-productivity-gap)
- [Customers](https://linearb.io/customers)
- [Pricing](https://linearb.io/pricing)
- [Why choose LinearB — Explore your data. Measure performance. Act to improve it.](https://linearb.io/why-linearb)
- [APEX framework — The operating model for AI-era engineering teams](https://linearb.io/resources/apex-framework)
- [Anti-FAQ — The questions other vendors won't answer](https://linearb.io/why-linearb/anti-faq)
- [Security — Enterprise-grade compliance and zero code access](https://linearb.io/security)
- [Build vs. buy — The hidden cost of building it yourself](https://linearb.io/resources/build-vs-buy)
- [Dev Interrupted Podcast — Conversations with engineering leaders](https://linearb.io/dev-interrupted/podcasts)
- [Reports & Guides — Deep dives on productivity and delivery](https://linearb.io/resources)
- [Webinars — Expert sessions on productivity and AI](https://linearb.io/resources?category=workshops)
- [Metrics Benchmarks — See how your engineering org stacks up](https://linearb.io/resources/software-engineering-benchmarks-report)
- [Blog — Product updates and practical insights](https://linearb.io/blog)
- [Help Center — Documentation, setup, and support](https://linearb.helpdocs.io)
- [API Docs](https://docs.linearb.io/api-overview)
- [Status](https://www.linearbstatus.com/)
- [Integrations](https://linearb.io/integrations)
- [LinearB Library](https://linearb.io/library)
- [Engineering metrics](https://linearb.io/library/engineering-metrics)
- [Platform engineering](https://linearb.io/library/platform-engineering)
- [Engineering glossary](https://linearb.io/library/engineering-glossary)
- [Developer productivity](https://linearb.io/library/developer-productivity)
- [AI in software development](https://linearb.io/library/ai-in-software-development)
- [Engineering management](https://linearb.io/library/engineering-management)
- [Developer experience](https://linearb.io/library/developer-experience)
- [DevOps](https://linearb.io/library/devops)
- [Engineering operations and the context layer](https://linearb.io/library/engineering-operations)
- [Engineering efficiency](https://linearb.io/library/engineering-efficiency)
- [Software delivery](https://linearb.io/library/software-delivery)
- [Research and data](https://linearb.io/library/engineering-benchmarks-and-research)
- [LinearB is a Leader in the 2026 Gartner® Magic Quadrant™ for Developer Productivity Insight Platforms](https://linearb.io/resources/gartner-magic-quadrant-dpi-platforms-2026)
- [Sign in](https://app.linearb.io/login)
- [Enterprise](https://linearb.io/solutions/enterprise)
- [Contact](https://linearb.io/contact-us)
- [About us](https://linearb.io/about-us)
- [Careers](https://linearb.io/careers)
- [Service agreement](https://linearb.io/services-agreement)
- [Privacy policy](https://linearb.io/privacy-policy)
- [DPA](https://linearb.io/data-processing-agreement)
- [Security FAQ](https://linearb.io/security-faq)
- [Substack](https://devinterrupted.substack.com/)

### Footer

_Additional links from the site footer, not repeated from the top navigation above._

- [GitHub](https://github.com/linear-b)
- [LinkedIn](https://www.linkedin.com/company/linearb)
- [Twitter](https://twitter.com/LinearB_Inc)