Amodal: The Agent Runtime Platform

The Elevator Pitch

Amodal is an open-source runtime for building AI agents that connect to your systems, follow your methodology, and take action on your behalf.

Connect Salesforce, Slack, Datadog, PagerDuty, HubSpot, Jira — whatever your team uses. Write skills as markdown: your sales playbook, your investigation runbook, your compliance checklist. The agent reads across all connected systems, reasons using your methodology, and acts: creates tasks, updates deals, isolates hosts, sends follow-ups. Not just answers. Actions across systems, with human confirmation at every write step.

This isn't a thin wrapper that gets eaten when models improve. Configuration is orthogonal to intelligence: even a perfect model still needs your OAuth tokens, your field-level access rules, your deal-staleness thresholds, and your escalation paths. That's not a model gap. It's a configuration layer that gets more valuable as models get smarter and more capable.

Open-source runtime. Community packages for connections and skills. A git repo you own. Deploy to Slack, Teams, or embed in your product. The platform adds observability, an admin UI for non-developers, and multi-tenant isolation for ISVs. Sales ops, security, finance, HR, marketing, meetings, customer success — same runtime, different skills.

The Three Gaps

Every team in every company has the same problem: critical information is scattered across systems, and acting on it requires logging into 6 different tools. The sales manager alt-tabs between Salesforce, LinkedIn, Slack, and a spreadsheet to figure out which deals need attention. The SOC analyst opens PagerDuty, CrowdStrike, Splunk, Okta, and Jira to investigate a single alert. The marketing VP checks HubSpot, Google Ads, LinkedIn Ads, GA, and Salesforce to understand campaign performance.

Then they act: create tasks, update records, send emails, reassign tickets, pause campaigns, flag risks. Each action is a separate login, a separate UI, a separate set of clicks. The context-gathering takes hours. The actions take more hours. And the next time the same question comes up, everyone starts from zero.

Amodal closes all three gaps: reads across systems, acts with confirmation, and learns from every session.

Use Cases

Two scenarios in depth. Same pattern: connect systems, write a skill as markdown, deploy. The agent reads across systems, reasons with your methodology, and takes action.

Not just answers. The agent creates tasks, updates records, sends emails, isolates hosts, reschedules people. Every write requires human confirmation.

The Developer Experience

A developer connects systems, writes skills as markdown, and deploys. The agent runs. That's the whole product from the developer's perspective. Here's what the repo looks like:

Your repo contains the domain-specific parts: skills (methodology), connections (system access), and knowledge (your org's context). Everything else is the platform.

{
  "slack": { "workspace": "acme", "channels": ["#sales-ops"] },
  "teams": { "tenant": "acme.onmicrosoft.com" },
  "web":   { "subdomain": "sales-agent" }
}

The Package Manager

Every developer ecosystem eventually gets a package manager. Node got npm. Python got pip. Rust got Cargo. Infrastructure got Terraform providers.

AI agents don't have one. There's no standard way to connect a system, share a skill, or version an automation. Every team reinvents the wiring from scratch. amodal connect and amodal install are the missing pieces.

Each agent is a project

{
  "lockVersion": 1,
  "packages": {
    "connection/salesforce": {
      "version": "2.1.0",
      "resolved": "registry.amodalai.com/..."
    },
    "connection/slack": {
      "version": "1.4.0",
      "resolved": "registry.amodalai.com/..."
    },
    "skill/deal-triage": {
      "version": "1.2.0",
      "resolved": "registry.amodalai.com/..."
    }
  }
}

Shared connections = one OAuth flow, not five. Shared skills = methodology propagates across every agent in the org.

The friction we're erasing

First-party connections cover the top 50 SaaS APIs. Community covers the long tail. Custom handles proprietary systems.

The Install Experience

Wiring up an agent to your systems today means writing API clients, managing OAuth flows, storing secrets, and teaching the model your API schema. Every connection is a weekend project.

amodal connect slack does all three in one command: runs the OAuth flow, stores credentials in .env, and loads API docs from the package. The agent gets access and understanding.

{
  "lockVersion": 1,
  "packages": {
    "connection/salesforce": {
      "version": "2.1.0",
      "resolved": "registry.amodalai.com/..."
    },
    "connection/slack": {
      "version": "1.3.0",
      "resolved": "registry.amodalai.com/..."
    },
    "skill/deal-triage": {
      "version": "2.0.1",
      "resolved": "registry.amodalai.com/..."
    }
  }
}

The Platform

The CLI is the developer experience. The platform is the team experience: admin UI for non-developers, observability for ops, session replay for quality, and cost management for finance. This is what teams pay for.

25 Years of Orchestration (and Why Every Solution Was Partial)

The need for orchestration didn't appear overnight. It grew alongside the SaaS stack itself. More tools meant more integration work. Every generation of orchestration solved one slice of the problem and left the rest. Understanding this history is understanding why Amodal exists.

Why Configuration Beats Intelligence

Models get smarter every quarter. GPT-3 to GPT-4 to Claude 3 to Claude 4 to whatever ships next month. Every AI startup built on a model gap is on borrowed time. If your product is "we make the model do X better," the model provider will ship that feature eventually. Chat wrappers, RAG pipelines, prompt chains, agent loops. All on the roadmap. All getting eaten.

Amodal isn't built on a model gap. It's built on a configuration gap. Even a model that knows everything still needs to be told what to do, how to do it, what it's allowed to do, and what your specific business looks like. That's not intelligence. That's configuration. And it's orthogonal to how smart the model is.

Point Solutions Are the New SaaS Sprawl

Every vertical is getting its own AI agent tool. 7AI for SOC ($36M Series A, 60+ purpose-built agents). Luthor for marketing compliance. Gong + Clari for revenue intelligence. Dropzone for investigation. Radiant for triage. The CISO buys one, the VP Sales buys another, the CCO buys a third.

Same data silos, different decade. The SOC agent can't tell the compliance team about an incident. The sales agent can't check marketing attribution. The compliance agent can't verify the SOC's access controls. Each tool connects to its own set of systems with its own credentials, its own dashboards, its own knowledge that doesn't compound across the org.

We've proven across 8 verticals (security, sales, marketing, compliance, HR, finance, ops, ISV) that one platform handles all of them. Same runtime. Same skill format. Same connection pattern. The SOC analyst writes a triage skill. The sales manager writes a deal review skill. The compliance officer writes a regulatory monitor skill. Different domain expertise, identical infrastructure.

The OSS Flywheel

The CLI is free and open source. That's not a leak. It's the strategy.

This is the Terraform / Docker / Elastic playbook. Give away the runtime. Charge for the enterprise wrapper. Own the ecosystem. Every free CLI user is a potential marketplace contributor AND a potential platform customer. The more people use the free tool, the more valuable the paid platform becomes.

The Marketplace Is the Moat

Models commoditize. Runtimes commoditize. What doesn't commoditize:

"I Have MCP. Why Do I Need Amodal?"

MCP (Model Context Protocol) is a protocol for connecting models to tools. It's plumbing. It solves "how does the model call an API." It does not solve:

MCP is one of the 5 files in an Amodal connection — it's the transport layer in spec.json. We could literally use MCP as the API call mechanism. It's complementary, not competitive. MCP connects the model to the API. Amodal tells the model what to do with it.

Becoming the Standard

Configuration matters. But lots of companies could build a configuration layer. The question is: why does ours become the standard? Three reasons: we're not a thin wrapper (the format is right), the infrastructure precedent proves the model works, and the open ecosystem compounds in a way that closed products can't match.

The Proven Playbook

The packaging layer for a new infrastructure category has produced multi-billion dollar outcomes three times in the last decade. Each time, the pattern is the same: an open-source CLI that developers love, a platform that teams pay for, and a community ecosystem that compounds.

AI agents are the next infrastructure category. The model providers build the engines. Amodal builds the packaging layer.

Free vs Paid

The runtime is open source. A developer can build and run a production agent without ever creating an Amodal account. The platform is what teams pay for: the capabilities that make agents manageable, observable, and improvable at scale.

Pricing

Two line items. Platform fee (flat or per-seat) covers the platform: admin UI, observability, evals, Model Arena, session replay, knowledge management, team features. Inference (usage-based) covers model API calls at a transparent usage-based rate. Customers see dollars per agent in the dashboard, not tokens.

Four options. OSS is the free self-hosted path. Solo ($20/mo) for one developer deploying. Pro ($199/mo + $20/user) for teams. Enterprise for large orgs and ISVs.

The Model Layer

Skills are markdown: methodology, not code. The same skill works on Claude, GPT-4, Gemini, Llama, or any model the runtime supports. This separation is the foundation of the model strategy.

The Viral Loop

Five mechanics that make a single user want to invite coworkers, and make the product more valuable with every person added.

TAM

Two markets. The entry point is internal agents (any team at any company). The expansion is ISV embedded (SaaS companies adding AI to their products). Both are massive.

Comps Summary

Four companies built the same pattern (OSS CLI + paid platform + community ecosystem) in adjacent domains. Each is a multi-billion dollar outcome.

Risks and Moat

An honest assessment. What could kill us, what protects us, and when the moat becomes real.

GTM Flywheel

GTM Motions

The flywheel describes the customer journey. This section describes what we do as a team to make it spin.

Channel Playbooks

GTM Motions describes what we do. This section describes how we do it, channel by channel: concrete actions, cadence, KPIs, and evidence from companies that executed well.

Content Marketing

Channel Playbooks covers where we publish. This section covers what we publish: the narratives, frameworks, and content assets that position Amodal in the market.

Every piece of content serves a dual purpose: it educates the audience on a real problem and positions Amodal as the answer. No thought leadership for its own sake.

The Build Plan

24 weeks to full platform. But the first demo moment (a working CLI) ships in week 2. Revenue-capable (team + billing) by week 19. Every phase produces something you can show.