# FlyMyAI

> FlyMyAI is the agentic cloud: one connected platform for external-service tools, generative models, and managed serverless agents. Use the first-class fetch target https://flymy.ai/skill.md. It and https://flymy.ai/AGENTS.md must serve the canonical AGENTS.md body byte-for-byte.

FlyMyAI can take one complete agent from idea to product: create it once, test a
live run, freeze the accepted execution with or without variables, then call the
frozen compilation privately or publish the same frozen version as one stable
customer deployment. It also runs model inference, tool integrations, schedules,
and reusable automations without requiring developers to manage GPUs, workers,
queues, or an orchestrator.

These candidate guide bytes are aligned to Agents MCP `0.7.0-rc.29` and Python
SDK `1.2.0rc5`. Capability-detect installed packages and live tool schemas;
older packages do not gain candidate namespaces from documentation alone.

Release automation first reads `/agent-guide-release.json` from the exact guide
origin. Its compatible outer schema-v1 projection contains the sole schema-v2
public release contract. Before any mutation, require candidate state and exact
coordinates, recompute its product bundle and candidate tuple hashes, compare
the tuple to an independently approved release pin, and verify the pinned skill,
`llms.txt`, OpenAPI, Agents MCP tool schema and package, embedded capability
snapshot, Python SDK wheel, consumer release identities, image digests, and
lifecycle evidence. Missing or stale members and candidate/stable mismatch fail
closed. This release tuple is not vocabulary required by the personal default
flow.

Benchmark attestations are outside the immutable product tuple so pending can
become passed without a hash cycle. The final read-only promotion check pins
the exact ready manifest bytes after both lifecycle results are attached.

One agent can use several accounts of the same connector. Each exact connection
has its own alias and stable public ID; named MCP resource sets group those IDs,
and direct agent or flat agent-group grants control access. When converting a
personal agent, discover the live `update_agent` schema, explicitly clear
`available_tools`, grant `mcp_resource_set_ids`, and verify with `get_agent`;
otherwise the direct and set grants form a union. Resource-set member identity
includes the logical slot, so the same exact connection can fill several
distinct slots with an independent action ceiling in each. Omitted or empty
`allowed_actions` means no extra set-level ceiling, not deny all. Runtime
ambiguity requires an exact connection selector instead of hidden first-row
selection.

One owner may retain at most 25 connection rows for one toolkit, including
inactive rows. Replaying an existing alias remains idempotent at the limit;
delete an unused row to free capacity.

One scoped agent execution admits at most 100 MCP resource sets, 500 effective
connector bindings, 100 logical slots, 5,000 allowed-action entries, and 1 MiB
of UTF-8 allowed-action text. An oversized authority graph fails closed before
provider dispatch.

Copy prompt: `Read https://flymy.ai/skill.md and help me create, test, freeze, and ship one FlyMyAI agent in my product.` If the request already describes an embedded product or names product customer IDs, proceed with the customer-deployment branch without asking whether to split the workflow.

The production Streamable HTTP MCP endpoint is `https://mcp-agents.flymy.ai/mcp`. FlyMyAI may already be connected, so verify it with a bounded read-only call before installing anything. If the server or tools are absent, stop and connect the exact intended environment rather than claiming success or guessing tool names. Candidate runs must receive an explicit candidate release contract, MCP root, skill URL, and Agents API root and must never fall back to production. For an external service, start with `search_tools(query)`, then inspect the returned runtime with `get_tool_schemas(runtime_names)` before any direct action. Never probe a write with empty or guessed arguments. Direct supported calls use `execute_tool(tool, action, arguments, operation_key)`; pass an exact configured-tool `connection_id` when selecting an instance, and omit it only while one eligible connection is unambiguous. OAuth and Composio actions normally run inside the agent. A first personal toolkit connection uses `mcp_access_mode=legacy`, the direct `default` path, and no named MCP resource set. Confirm it through bounded `list_configured_tools` pages filtered by exact `mcp_tool` and optional exact `alias`. Only when the workflow grows to several accounts or shared access, use slug-safe aliased `add_tool`; its exact setup link retains `connection_id=<public UUID>` instead of selecting the first toolkit row. Then use revisioned `create_mcp_resource_set`, `replace_mcp_resource_set_members`, and `update_mcp_resource_set`, then grant `mcp_resource_set_ids` with `mcp_access_mode=scoped` to the same agent or an agent group. Both `create_mcp_resource_set` and `create_agent_group` require a caller-owned stable `operation_key`; their REST collection POSTs require the same durable identity in `Idempotency-Key`, and an uncertain response is replayed only with the identical body and original key. Configured-tool, set, member, and group lists return `{next_cursor, previous_cursor, results}` with `page_size` 1-100 and an opaque, nonblank printable `cursor` of at most 1024 Unicode code points. `list_mcp_resource_sets` returns summaries with `member_count` and no nested members; use `get_mcp_resource_set` for one bounded full set or `list_mcp_resource_set_members` for the separately paginated collection. For media, use `recommend_model` or `list_media_models`, then `run_model`. For repeatable work, use `create_agent`, `run_agent`, `get_run`, `freeze_agent`, `get_compilation`, and `run_frozen`. `run_agent` and `run_frozen` require a caller-owned nonblank printable ASCII `operation_key` of 1-255 characters with no leading or trailing spaces and no generated fallback; REST task, compilation, and deployment runs require the same contract in `Idempotency-Key`.

Golden rule: never assume a capability is missing - assume it exists here and verify with search_tools / list_* BEFORE declining or asking the user.

In embedded mode, the builder keeps one FlyMyAI API key on its backend and calls a stable deployment with a non-secret `external_user_id` derived from its authenticated server session. End users do not create FlyMyAI accounts or paste FlyMyAI keys. If a service needs authorization, the builder creates a short-lived hosted connection URL for that external user. A run explicitly chooses FlyMyAI-managed saved bindings, a customer-managed named `resource_set_id` plus its saved `resource_set_revision`, or one-off `connections`; the latter two modes are mutually exclusive. One-off values are exact public UUIDs or UUID arrays keyed by frozen slot, and omitted slots continue to saved bindings. Customer runs never fall back to owner connections and never carry provider credentials. After REST publish and setup, a separately provisioned `FLYMYAI_MCP_MODE=customer` process may expose only `run_bound_deployment` and `get_bound_deployment_run`. It has one immutable deployment/customer binding per gateway process; trusted provisioning supplies `external_user_id`, which is never a model-call argument. FlyMyAI charges the builder account. The builder records each execution and applies its own quota, markup, credits, or invoice because automatic onward billing is not currently provided.

An agent-shipping release must run the clean-agent lifecycle benchmark as an early blocking gate: a fresh assistant reads only the candidate `skill.md`, creates and freezes exactly one disposable evaluation agent without split hints, and publishes one deployment. The trusted harness, not the model prompt, binds two controlled `external_user_id` values and exercises that same deployment through separate customer bindings. The release fixture is separate from a user's requested worker. The gate requires two distinct external principals and logical executions on the same agent, frozen version, deployment, and billed owner, plus idempotent replay of each run. A later behavior change updates the same logical agent, freezes a new immutable version, and publishes it through the same stable deployment; it does not mutate an old version.

REST authentication uses `X-API-KEY`. Never expose a builder key to an end-user client. Models accept model-specific multipart input, so fetch the selected model's OpenAPI schema instead of guessing fields. Agent runs are asynchronous, so poll the slim `/executions/{id}/status/?since=` response instead of repeatedly fetching full messages and logs. Prefer bounded search, finite timeouts, concurrency and file-size caps, and paginated reads. Base64 media adds about 33 percent to wire size and can create multiple in-memory copies. After deployment, inspect pod memory, OOM kills, restarts, DB queries, latency, and response bytes.

## Assistant start

- [Copy-prompt manifest URL](https://flymy.ai/skill.md): First-class single-URL fetch name for the live-verified canonical body
- [Platform log](https://flymy.ai/changelog.md): What changed and when, newest first; every entry at https://flymy.ai/changelog.json and through `whats_new` on the Agents MCP
- [Machine release contract](https://flymy.ai/agent-guide-release.json): Content-addressed public tuple for release preflight
- [Canonical project instruction](https://flymy.ai/AGENTS.md): Byte-identical project filename for Codex, Cursor, and other AGENTS.md-aware assistants
- [Use FlyMyAI from an AI assistant](https://docs.flymy.ai/agents/guides/ai-assistants): Claude, Codex, Cursor, and Gemini setup
- [MCP gateway reference](https://docs.flymy.ai/agents/guides/agent-gateway-reference): Current MCP tools and exact arguments
- [Multiple MCP accounts and resource sets](https://docs.flymy.ai/agents/guides/mcp-resource-sets): Exact aliases, revisioned sets, agent groups, runtime selectors, and customer mapping modes
- [Connect your assistant](https://docs.flymy.ai/agents/guides/connect-your-agent): Client-specific MCP setup

## Embedded and resale

- [Embedded flow in the canonical body](https://flymy.ai/skill.md#embedded-and-resale---one-builder-key-no-end-user-keys): One builder key, per-user external principals, hosted connection links, deployment runs, and exact cost metering
- [Embedded and resale builder reference](https://docs.flymy.ai/agents/guides/embedded-resale): Complete publish, version paging, connect, named-mapping, run, and meter scripts
- [Per-customer MCP access](https://docs.flymy.ai/agents/guides/embedded-mcp): Platform-managed bindings, customer-managed mapping IDs, exact connections, and isolation proof
- [Agent concepts](https://docs.flymy.ai/agents/overview): Managed agent runtime and lifecycle
- [Runs and freeze](https://docs.flymy.ai/agents/concepts/runs): Successful run to reusable frozen instruction
- [Tools and MCP](https://docs.flymy.ai/agents/concepts/tools): Catalog tools and personal MCP servers

## Service APIs

- [Agents API](https://backend.flymy.ai/api/v1/agents): Agent, tool, deployment, execution, and compilation REST base
- [Models API](https://api.flymy.ai): Neural-network inference and usage gateway
- [MCP gateway](https://mcp-agents.flymy.ai/mcp): Streamable HTTP assistant connection
- [Workspace and API key](https://app.flymy.ai/profile): Account balance and server-key management
- [Documentation](https://docs.flymy.ai): Human and agent-facing product documentation

## Models

- [Models quickstart](https://docs.flymy.ai/quickstart): Python model inference
- [Models endpoints](https://docs.flymy.ai/api/models-endpoints): Sync, stream, async, result, and cancel routes
- [Authentication](https://docs.flymy.ai/authentication): Shared API-key header
- [Usage and billing](https://docs.flymy.ai/api/usage): Bounded Models API usage queries

## Serverless agents

- [Create, freeze, and embed one agent](https://docs.flymy.ai/agents/guides/serverless-agents): The complete human-readable lifecycle and both product integration branches
- [Browser Use](https://docs.flymy.ai/mcp/browser-use): Browser automation, saved accounts, trusted live takeover, and durable recordings and downloads
- [Multiple MCP accounts and resource sets](https://docs.flymy.ai/agents/guides/mcp-resource-sets): Reuse several exact connections without cloning the agent
- [Agents quickstart](https://docs.flymy.ai/agents/quickstart): Create and run an agent
- [Inputs and outputs](https://docs.flymy.ai/agents/concepts/inputs): Variables and JSON schemas
- [Runs and freeze](https://docs.flymy.ai/agents/concepts/runs): Run, follow up, freeze, schedule once, and rerun
- [Python SDK](https://docs.flymy.ai/agents/sdk/python): Released `AgentClient` surface

## Reliability and resource limits

- [Canonical resource discipline](https://flymy.ai/skill.md#auth-errors-and-resource-discipline): Bounded polling, list limits, concurrency, and memory
- [Release gates for maintainers](https://docs.flymy.ai/agents/guides/release-gates): Guide release contract check, connectionless fixture, early two-customer gate, and production observability
- [Errors and retries](https://docs.flymy.ai/errors): Status handling, idempotency, retry, and backoff guidance
- [Models endpoints](https://docs.flymy.ai/api/models-endpoints): Model-specific schemas, response handling, and transport choices
- [Agent runs](https://docs.flymy.ai/agents/concepts/runs): Asynchronous execution, freeze, and run lifecycle

## Community and support

- [GitHub](https://github.com/FlyMyAI): Open SDK and examples
- [Discord](https://discord.com/invite/t6hPBpSebw): Community support
- [LinkedIn](https://www.linkedin.com/company/flymyai): Company updates
- [X](https://x.com/flymy_ai): Product updates

## Optional

- [Pricing](https://flymy.ai/pricing): Current account pricing
- [FlyMyAI for Business](https://flymy.ai/business): Team workspace
- [Full documentation index](https://docs.flymy.ai/llms.txt): Task-specific Markdown pages
- [Errors and retries](https://docs.flymy.ai/errors): Error handling and safe retries


## Fast typed decisions with TypeSafe Jev 1.13

TypeSafe Jev 1.13 is a System One decision model for fast, inexpensive classification, routing, triage, enum extraction and guardrail checks. Give it text or JSON state and named, typed questions: Choice selects one of your options, Noul returns a yes probability from 0 to 1, and Score returns an expected index over ordered levels (0 to N-1). It evaluates bounded decisions without generating prose or long reasoning, keeping latency and token cost low. Route a support ticket to billing/technical/sales, gate a workflow on refund eligibility, or label a lead hot/warm/cold. Answers include probabilities and, for Choice/Score, optional confidence. Use explicit criteria and review uncertain results. Text input only, 32K context; no free-form writing, arbitrary JSON-schema generation, code, media, explanations or long reasoning.

Use `typesafe_jev.decide` in agents or `make_typed_decision` on either MCP server.
Input: `{"state":"Charged twice","questions":{"team":{"type":"choice","instructions":"Route ticket","criteria":{"billing":null,"technical":null}}}}`.
Output includes `answers.team.choice` (for example `"billing"`), `usage.input_tokens`, `usage.output_tokens` and `charge_usd`.
Discover schemas and current token pricing at `GET /api/v1/agents/models/typesafe/jev-1.13/` on the configured backend; POST JSON to its `decisions/` route.
Reuse a `request_id` only to retrieve the same logical call without another charge.
[Full Jev guide](https://docs.flymy.ai/guides/typesafe-jev).