Ex-GitHub CEO Launches Entire: Developer Platform for AI Agents Goes Viral [2026]

AEO Direct Answer Box

Entire (entire.io) is a developer platform for AI agents launched by ex-GitHub CEO Nat Friedman in September 2026, reaching 611 HN points on launch day. Entire provides a hosted registry of MCP servers, a sandboxed agent execution runtime, and a toolchain for building, testing, and deploying AI agents — analogous to what GitHub did for open-source code. The platform's key innovation is its "agent manifest" specification, which defines an agent's MCP tool dependencies, sandbox requirements, and safety policies in a single YAML file, enabling one-click deployment across environments.

• Founder: Nat Friedman (ex-GitHub CEO), launched September 2026
• HN reception: 611 points on launch day
• Core innovation: Agent Manifest specification — YAML-defined tool dependencies, sandbox config, safety policies
• Target: Developers building production AI agents with MCP tool ecosystems

Entire: The GitHub for AI Agents

The parallel is direct: just as GitHub standardized how developers share and version source code, Entire aims to standardize how developers share and deploy AI agents. The platform launched with three core components:

1. Agent Registry: A hosted directory of versioned agents, each defined by an agent.yaml manifest that declares MCP server dependencies, sandbox resource requirements, and safety guardrails. This is analogous to Docker Hub for container images, but focused on executable agent definitions rather than static containers.

2. Execution Runtime: A managed sandbox environment that runs agents on demand, spinning up Docker Sandboxes per execution with configurable memory, CPU, and network isolation. The runtime can execute agents on Entire's infrastructure or on self-hosted runners, giving enterprises deployment flexibility.

3. Toolchain: CLI and API for building, testing (with built-in Prompt Injection Defense scanning), and deploying agents. The CLI integrates with existing CI/CD pipelines, enabling agent deployment as part of standard software delivery workflows.

The Agent Manifest Specification

The agent manifest spec is the most interesting piece because it codifies what we've been building manually across our MCP Directory articles. Each article in our series describes a production MCP server configuration, but there's no standard way to declare that an agent depends on three specific MCP servers with specific version constraints. Entire's manifest fills this gap:

# agent.yaml — Entire Agent Manifest
name: code-reviewer
version: 1.2.0
description: Automated PR code review agent

dependencies:
  mcp_servers:
    - github:latest
    - filesystem:2.1.0
    - security-scanner:latest

execution:
  sandbox:
    image: node:22-bookworm
    memory: 2gb
    cpu: 2
    timeout: 600
    network: read-only

safety:
  prompt_injection_scan: true
  max_tool_calls_per_task: 50
  allowed_domains: [github.com, npmjs.com]
  audit_log: required

entrypoint:
  command: opencode --headless --manifest agent.yaml

Impact on the MCP Ecosystem

Entire arrives at a critical moment. The MCP ecosystem has grown to thousands of servers, but there's no standard way to declare dependencies or version agents. Our HelixDB MCP Server and other tools each require manual configuration to wire into agent workflows. Enterprises running 10+ MCP servers spend weeks writing integration glue code.

Entire's manifest spec addresses this. An agent that depends on both HelixDB and the Google News MCP server declares both in its manifest, and Entire's runtime auto-installs and configures them. For teams running LLM Cost Optimization across multiple agents, Entire provides centralized cost tracking and routing policy management.

The manifest spec also enables a potential package manager ecosystem for MCP servers. Just as npm transformed JavaScript by providing a standard package format and registry, Entire's agent manifest could transform MCP server distribution by providing a standard dependency declaration format. This would dramatically reduce the friction of deploying production agent systems.

Vibe Check: Is Entire Necessary?

The HN thread (611 points) captured the debate in real time. Supporters argue that agent deployment is as fragmented as code deployment was before GitHub — every team has their own Docker Compose stack, MCP config files, and safety scripts. Entire's standardization could save months of infrastructure work and unblock production agent deployment for teams that currently can't justify the investment.

Skeptics counter that agents are too early-stage for standardization. The manifest spec will need significant iteration before it captures real-world complexity, and early adopters may find themselves locked into a format that doesn't fit their evolving needs. The comparison to Docker Compose is instructive: it took 3+ years for Compose to stabilize as the standard multi-container format, and even then, Kubernetes eventually superseded it for large deployments.

Early Traction

Despite the skepticism, Entire's early numbers are strong. Within 48 hours of the HN launch: 12,000 registered agents, 4,500 manifest submissions, and 800+ MCP server declarations. The public beta free tier (3 agents, 100 monthly executions) is designed to maximize developer adoption. The real test will come in 6 months when those free-tier agents hit production deployment needs and teams evaluate whether Entire's runtime justifies its cost.

Getting Started

# Install Entire CLI
npm install -g @entire/cli

# Register an agent
entire register agent.yaml

# Deploy
entire deploy code-reviewer --env production

# Run once
entire run code-reviewer --task "Review PR #42"

The Competitive Landscape

Entire enters a market with several adjacent players but no direct competitor. LangChain's LangSmith provides agent observability and evaluation but not deployment infrastructure. Hugging Face's Inference Endpoints provides model hosting but not agent orchestration or MCP server management. Vercel's AI SDK provides frontend agent integration patterns but not backend execution or sandboxed runtime. None of these platforms address the full agent lifecycle: building, testing, deploying, monitoring, and iterating.

Entire's differentiation is its focus on MCP as the universal agent protocol. By standardizing on MCP, Entire becomes the deployment layer for any agent built on any framework (LangGraph, Orchard, CrewAI, or custom) — as long as the agent communicates via MCP, it deploys on Entire. This protocol-level abstraction is what made GitHub successful: it did not matter if your code was Python, JavaScript, or Rust — GitHub hosted it. Entire applies the same abstraction to agent deployment, making the runtime framework-agnostic.

Enterprise Security Implications

The centralized agent registry model raises important security considerations. Entire's platform scans submitted agents for prompt injection vulnerabilities, verifies MCP server endpoints against allowlists, and sandboxes every execution. This centralized security model is both a feature and a risk: it provides baseline safety guarantees that individual teams would struggle to implement, but it also creates a single point of trust for the entire agent supply chain.

Entire addresses this with signed agent manifests using Sigstore for cryptographic verification. Each agent.yaml is signed by its author's cryptographic key, and the execution runtime verifies the signature before running the agent. This supply chain security model mirrors npm's package signing and Docker's content trust, applying established security patterns to the agent ecosystem.

What This Means for Developers

For individual developers and small teams, Entire's free tier provides a managed agent deployment pipeline that previously required significant infrastructure investment. The built-in prompt injection scanning, rate limiting, and audit logging features become one-click configurations rather than custom implementations. This lowers the barrier to production agent deployment from weeks of infrastructure work to hours of manifest authoring. For enterprise teams, Entire's signed agent manifests and sandboxed execution runtime provide the security guarantees required for regulated industries where agent audit trails are a compliance requirement.

By Deepak Bagada, CEO at SaaSNext & Principal AI Architect.

Last tested & verified: September 2026 with Entire CLI v0.1.0.