Alpha testing
Agent Executor
aex is an agent execution platform for launching autonomous agents from a simple TypeScript SDK and CLI.
Open durable agent sessions, send turns, stream events, capture outputs, and compose agents with skills, files, MCP, secrets, networking controls, and subagents across the managed runtime.
npm i @aexhq/sdkimport { Aex, Models, Sizes } from "@aexhq/sdk";
const aex = new Aex({ apiKey: process.env.AEX_API_KEY! });
const session = await aex.openSession({
model: Models.CLAUDE_HAIKU_4_5,
system: "You are a concise engineering assistant.",
runtime: Sizes.SHARED_0_25X_1GB,
overrides: { idleTtl: "3m" },
apiKeys: { anthropic: process.env.ANTHROPIC_API_KEY! }
});
const result = await session.send("Write a short report and save it as a file.").done();
console.log(result.status, result.text);Anthropic · DeepSeek · OpenAI · Gemini · Mistral · OpenRouter · Doubao · Doubao China
Platform
Everything an agent needs to run
Agent runtime
Managed autonomous runs with filesystem read/edit, grep/glob/head/tail, open web fetch/search, background commands, code execution, git, and subagents.
Durable infrastructure
Run records, status, wait/cancel/delete, idempotency, typed events, output capture, downloads, timeouts, and runtime sizes.
Agent composition
Skills, files, AGENTS.md, remote MCP servers, environment variables, packages, secrets, and networking controls.
Subagents
Typed parent/child lineage for async child runs, output handoff, and bounded agent delegation.
Models and providers
Anthropic, DeepSeek, OpenAI, Gemini, Mistral, OpenRouter, Doubao, and Doubao China behind one submission shape.
Typed control surface
Strongly typed SDK inputs, CLI parity, BYOK provider keys, workspace secrets, redaction, and output modes.
Subagents
Fan out, recurse, collect
Every run carries a subagent tool. The agent can hand work to child runs that execute concurrently — and children can spawn children of their own. The platform tracks the whole tree as typed parent/child lineage and hands each result back to the run that asked for it.
- 1,000
- concurrent children per run, by default
- 4,096
- platform ceiling, reachable with per-run overrides
- 5
- levels of recursive delegation per lineage
Native tools
A full computer, ready on turn one
Managed runs land in an isolated runtime with the complete builtin toolset injected by default — shell, files, search, web access, git, background jobs, code execution, and subagents.
- bash
- read_file
- write_file
- edit_file
- grep
- glob
- head
- tail
- todo_write
- subagent
- subagent_result
- web_fetch
- web_search
- bash_output
- bash_kill
- code_execution
- wait
- git
- ls
- stat
- wc
Yours to shape
Set includeBuiltinTools: false for a pure-MCP or pure-custom run, or cherry-pick a narrow subset of builtins next to your own tools.
Networking included
Agents reach the public internet through an SSRF-guarded path by default. Flip a run to limited mode to allowlist exactly the hosts it may touch.
Composition
Assemble agents from parts
A run is composed from explicit inputs. The SDK materializes local bytes before the session lands, and the platform mounts everything into the runtime before the first agent turn.
Skills
Bundle SKILL.md plus supporting files from a directory or URL. Bytes are content-hashed and deduplicated, and every file is staged into the workspace before the first turn.
Files & instructions
Attach reference files and folders from paths or bytes, and steer the agent with AGENTS.md content — inline or from disk.
Remote MCP servers
Declare remote MCP servers next to builtin and custom tools. Their tools join the same tool list; credentials ride the secret surface, never the config.
Secrets & environment
Environment variables, package installs, per-host networking, and runtime secrets by value or reference. Provider keys stay in their own per-provider map.
Infrastructure
Durable by design
A run is a durable record with a lifecycle — not a connection you have to babysit.
Durable sessions
Sessions snapshot their inputs, park when idle, and resume by id. The SDK, CLI, and dashboard all read the same run record.
Typed events
Every step lands in an ordered, typed event stream — follow it live or replay it after the run parks.
Captured outputs
Files the agent writes are captured to durable storage, listed on the run, and downloadable behind auth.
Safe retries
Idempotency keys make opening sessions and sending turns safe to retry — the same key and body return the existing run.
Finish webhooks
Register a callback and receive a signed webhook the moment a run reaches a terminal state — no polling loop.
Bounded by default
Timeouts, spend caps, storage quotas, and concurrency limits — every knob has a sane default and a hard ceiling.
Integration
Three calls to your first result
01
openSession()Pick a provider and model, attach skills, files, and MCP servers, and bring your own API key.
02
send()Send a turn. Stream typed events as the agent works, or fire and forget — the run is durable either way.
03
done()Await the result, read outputs, download the workspace — from TypeScript or the aex CLI, they share one record.
One submission shape across all 8 providers — swap the model and the key, nothing else changes.
Pricing
Infrastructure rates, your tokens at cost
The plan fee is your included usage. Past it you pay the same list rates — no overage premium, no credit math. BYOK model tokens are never marked up: $0.
Free
$0/mo
$5 of usage included each month
- No card required
- Hard stop at the allowance
- Community support
Pro
$20/mo
$20 of usage included each month
- Pay-as-you-go past the allowance, at the same list rates
- Default $200 monthly budget, adjustable
- Run webhooks and higher rate limits
Team
$200/mo
$200 of usage included each month
- Pay-as-you-go at the same list rates
- Default $2,000 monthly budget, adjustable
- Priority support
Per-second billing; idle session time is free. A typical run costs $0.02–0.10, plus your own tokens.
Access is limited to invited testers while we harden the hosted runtime, dashboard, and SDK workflows.