# Maritime YC F26: Managed Cloud for Production AI Agents at $1/Agent

> Source: <https://explainx.ai/blog/maritime-yc-f26-managed-cloud-production-ai-agents-november-2026?utm_source=rss&utm_medium=feed&utm_campaign=blog>
> Published: 2026-11-19 00:00:00+00:00

**Key takeaway:** Maritime's provision({ externalId }) API creates one persistent micro-VM per end customer idempotently, with agent boxes billed at $1 per month per 2 GB of RAM awake or asleep and about 1-second wake latency.

**Maritime is a Y Combinator Fall 2026 managed cloud that gives every end-user AI agent its own isolated, persistent computer** instead of sharing one ephemeral sandbox across customers. Founders Maria Gorskikh and Aryaman Shrivastava opened a [Launch HN thread](https://news.ycombinator.com/item?id=50549188&ref=explainx) on November 18, 2026 pointing builders to [maritime.sh](https://maritime.sh/?ref=explainx) and the [YC company profile](https://www.ycombinator.com/companies/maritime?ref=explainx).

The bet is product shape, not a new model. As multi-tenant **personal assistant** products, [Grok Bot marketplaces](https://explainx.ai/blog/spacexai-grok-bot-marketplace-launch-2026), and coding agents move toward **one agent per customer**, teams lose weeks to provisioning, sleep and wake, login handoffs, and fleet updates. Maritime wraps micro-VMs with billing, monitoring, and SDK methods so startups can sell agent products without operating a miniature cloud provider.

## TL;DR

| Question | Answer (per Maritime docs, Nov 2026) | 
|---|---|
| What ships? | Isolated agent boxes, optional sandboxes, Linux/Windows desktops, Android phones | 
| Entry price | Agent box from **$1/month per 2 GB** (awake or asleep) | 
| Core API | `provision({ externalId })` for idempotent per-customer agents | 
| Wake latency | About **1 second** for agent boxes (site and Launch HN) | 
| Trial | 7-day trial; card when first machine starts | 
| Founders | MIT NANDA alumni; YC F26 | 

## Why Maritime exists now

Maritime’s Launch HN post argues that **sandboxes are only part of production agents**. Builders still need lifecycle management: triggers, schedules, recovery, per-agent spend caps, login handoffs for Gmail or OAuth, and fleet rollouts when you ship a new image.

That matches what explainx.ai has tracked across [agent sandbox comparisons](https://explainx.ai/blog/agent-sandboxes-coding-agents-compared-e2b-modal-daytona-guide-2026), [AWS AgentCore identity](https://explainx.ai/blog/aws-bedrock-agentcore-identity-private-ca-november-2026), and [Codex harness hosting](https://explainx.ai/blog/codex-as-a-platform-open-agent-harness-august-2026). Ephemeral runtimes excel at **one-shot code execution**. Products like personal assistants or vertical **AI employees** need **state that survives between tasks**.

Maritime targets teams **selling** agents, not hobbyists running a single CLI session. The YC launch names startups that want **millions of isolated agents** with operations handled for them.

Maritime marketing visual for isolated agent micro-VM fleets
*Image: [Maritime (YC F26)](https://maritime.sh/?ref=explainx)*

## What Maritime manages under the hood

According to the founders’ HN introduction and the [SDK reference](https://maritime.sh/docs/sdk?ref=explainx), Maritime composes:

| Layer | What the platform handles | 
|---|---|
| Compute | Micro-VM per agent with persistent disk | 
| Orchestration | Sleep, wake, triggers, schedules, rollbacks | 
| Observability | Logs, per-agent spend tracking, monitoring hooks | 
| Network | Internet policy, private access rules, connection tests | 
| Channels | Webhooks with rotate-able invoke tokens | 

Maritime also documents **Agent boxes**, **Sandboxes** (with Swarms on higher plans), and **Computers** (Linux, Windows, Android) as separate machine types. Coding flows might use Sandboxes for generated code and Agent boxes for the long-lived customer assistant.

Maritime managed cloud dashboard for production AI agents with per-customer isolated VMs
*Image: [Maritime (YC F26)](https://maritime.sh/?ref=explainx)*

## Pricing: agent boxes vs bursty sandboxes

[maritime.sh/pricing](https://maritime.sh/pricing?ref=explainx) separates **always-addressable agent boxes** from **per-second sandboxes and desktops**.

**Agent boxes** bill **$1 per month per 2 GB** of RAM whether the machine is awake or asleep, with unlimited awake hours on that tier and **5 GB disk** included. More disk is **$0.08 per GB-month**. A 4 GB box is $2 per month on that table.

**Sandboxes** bill while awake at **$0.0055 per vCPU-hour plus $0.00275 per GB-hour** (the default 2 vCPU / 4 GB size is **$0.022/hour** on the pricing page). Linux desktops, Windows desktops, and Android phones have higher hourly rates while awake.

Plans (**Starter $20**, **Growth $100**, **Scale $500**, **Dedicated $5,000**) convert the monthly fee into usage credit and cap how many machines can be awake concurrently (5, 25, 60, and 500 on the public tiers). The trial stops usage at **$20** unless you convert on day seven.

For founders comparing unit economics, the headline **$1 agent** is the contrast to always-on GPU sandboxes. You still pay model API costs; Maritime does not bundle AI credits.

## SDK: provision one VM per customer ID

The [Agents SDK page](https://maritime.sh/docs/sdk/agents?ref=explainx) is the integration surface most SaaS teams will read first.

The recommended pattern is **`provision({ externalId, … })`**: idempotent create-or-return keyed to your customer identifier. That mirrors how billing systems think about seats.

Other methods cover the lifecycle builders asked about on HN:

| Method family | Typical use | 
|---|---|
| `chat` ,`exec` ,`logs` | Operate a deployed agent without SSH | 
| `sleep` /`wake` /`restart` | Cost control and recovery | 
| `setEnv` /`reloadEnv` | Secrets and configuration pushes | 
| `network` /`testNetwork` | Egress policy before production | 
| `webhookToken` | HTTP triggers that wake sleeping agents | 

Maritime documents TypeScript and Python clients with the same surface. Errors on sleeping agents return **Retry-After** semantics so clients can backoff, per the SDK notes.

Maritime light-theme fleet dashboard for per-customer agent VMs
*Image: [Maritime (YC F26)](https://maritime.sh/?ref=explainx)*

## How Maritime compares to E2B, Modal, and DIY AWS

Maritime maintains [maritime.sh/compare.md](https://maritime.sh/compare.md?ref=explainx), a source-linked matrix against **E2B, Daytona, Modal, Vercel Sandbox, Boat, Browserbase, Windows 365 for Agents, AWS**, and others. Treat it as vendor positioning, not neutral benchmarking, but it states Maritime’s design goal clearly: **persistent per-user computers with sleep and wake**, not only ephemeral execution.

If you already run agents on [Modal](https://explainx.ai/blog/agent-sandboxes-coding-agents-compared-e2b-modal-daytona-guide-2026) or [E2B](https://explainx.ai/blog/agent-sandboxes-coding-agents-compared-e2b-modal-daytona-guide-2026) for coding tasks, Maritime is pitching the **next layer up** when your product gives every customer a named agent with files and logins intact.

Several HN commenters said they self-hosted on AWS with credits. Maritime’s answer in the thread is that **lifecycle and cost optimizations** (scale-to-zero, copy-on-write images, compressed memory snapshots) are the product, not raw VM rental.

## What developers are saying on Hacker News

The [Launch HN thread](https://news.ycombinator.com/item?id=50549188&ref=explainx) had substantive builder questions by November 19, 2026 UTC.

**binsquare** [framed the category](https://news.ycombinator.com/item?id=50550558&ref=explainx) as evolution from VMs to serverless agents, comparing the moment to EC2 and functions.

**ATechGuy2** [noted lifecycle management](https://news.ycombinator.com/item?id=50550576&ref=explainx) on top of micro-VMs as the painful production layer, from experience at a neocloud.

**agent_yard** [asked how spend caps behave](https://news.ycombinator.com/item?id=50554975&ref=explainx) when an agent loops mid-task, and how wakeup interacts with checkpoints—questions Maritime’s docs partially answer through `stop`, `sleep`, and webhook triggers, but buyers will still stress-test in trial.

**stevelacey** [argued many builders](https://news.ycombinator.com/item?id=50554024&ref=explainx) only need Claude Code in tmux plus Telegram, challenging the managed-cloud value prop for solo developers.

**MisterMunchkin** [questioned economics](https://news.ycombinator.com/item?id=50553017&ref=explainx) at $1 per month versus YC funding and crowded competitors—a fair founder concern when model APIs dominate margin.

Paraphrase commenter reports as opinion, not verified benchmarks. The thread’s signal is **buyer sophistication**: teams already run agents and want concrete answers on caps, OAuth, and state—not hype.

## How to try Maritime this week

1. Create an account at [maritime.sh](https://maritime.sh/?ref=explainx) . The site advertises**three agents free** to start and documents the**7-day trial** flow on the pricing page.
2. Install the SDK from Maritime’s docs and call **`provision`** with a test` externalId` tied to a fake customer record in your staging database.
3. Deploy your agent image or use a documented template so the container is not a broken bare framework (the SDK warns that empty templates produce bad images).
4. Set **`network`** rules before you connect production OAuth secrets; pair with your existing[MCP security checklist](https://explainx.ai/blog/mcp-security-guide-2026) if the agent uses tools.
5. Compare wake latency and monthly box cost against your current [sandbox bill](https://explainx.ai/blog/agent-sandboxes-coding-agents-compared-e2b-modal-daytona-guide-2026) on realistic idle patterns.

If you sell agents to enterprises, read Maritime’s **Dedicated** plan as a signal they expect **hands-on onboarding** for larger fleets, similar to how [Microsoft Agent 365](https://explainx.ai/blog/microsoft-ignite-2026-complete-coverage-every-announcement-november-2026) pitches FinOps for agents.

## Machine types beyond agent boxes

Maritime’s marketing site groups **Sandboxes**, **Swarms**, **Computers**, and **Android phones** as separate products. That matters when your agent needs a browser desktop, a mobile app workflow, or parallel rollout workers.

| Machine type | When builders pick it | 
|---|---|
| Agent box | Default per-customer persistent assistant | 
| Sandbox | Short coding or tool bursts inside Swarms on Scale+ | 
| Linux desktop | Full GUI computer-use loops | 
| Windows desktop | Apps that only exist on Windows | 
| Android phone | Mobile-only flows or messaging apps | 

The [agent guide](https://maritime.sh/agent-guide.md?ref=explainx) on Maritime’s domain is written for agents themselves, listing prices and API entry points. For human teams, treat it as a machine-readable supplement to the dashboard docs.

## Integration patterns that fit Maritime

**MCP bridge:** Maritime says you can keep your agent logic on your existing backend and use MCP to control a Maritime computer. That mirrors how [Home Assistant HA-MCP](https://explainx.ai/blog/homeassistant-ha-mcp-claude-chatgpt-mcp-server-2026) keeps the brain in Claude while tools run elsewhere.

**Bring your own harness:** Docs name OpenClaw, Hermes, Claude Agent SDK, and Codex images. If you already standardized on [OpenCode 2.0](https://explainx.ai/blog/opencode-2-0-code-mode-background-agents-shared-server-sdk-upgrade-guide-2026) for coding, you might still park customer-specific state on Maritime while batch coding stays in CI sandboxes.

**Marketplace products:** [Grok Bot-style marketplaces](https://explainx.ai/blog/spacexai-grok-bot-marketplace-launch-2026) imply many tenants and heterogenous skills. Maritime’s per-`externalId` provision call is the hook those products need so two customers never share one disk by accident.

## Security and trust boundaries

Maritime runs customer agents on its infrastructure. That shifts responsibility: your threat model must cover **Maritime’s control plane**, webhook URLs that wake agents, and **secrets stored via `setEnv`**.

This is not a breach post. If your agents call production APIs, still apply the patterns in [Nadella’s compromised-model containment talk](https://explainx.ai/blog/nadella-assume-ai-models-compromised-emergency-brake-containment-2026) and isolate credentials per agent box.

## What Maritime does not solve

Maritime does not replace **model routing**, **eval harnesses**, or **legal review** of agent actions. You still need [verification workflows](https://explainx.ai/blog/together-ai-agent-evals-97-percent-coding-agents-november-2026) and product policies.

It also does not eliminate **vendor lock-in**: migrating off a hosted per-user VM platform means exporting customer disk state and rebuild images.
