Deterministic execution engine for AI agents. 300+ atomic modules, evidence snapshots, execution trace, replay from any step.

pip install flyto-core[api]
python -m core.quickstart

That's it. In 30 seconds you'll see:

1. A 5-step workflow execute with full trace
2. Evidence snapshots (context_before/after) for every step
3. Replay from step 3 — without re-running steps 1-2

AI agents are running multi-step tasks — browsing, calling APIs, moving data. But after they finish, all you have is a chat log.

Flyto Core gives you:

• Execution Trace — structured record of every step: input, output, timing, status
• Evidence Snapshots — full context_before and context_after at every step boundary
• Replay — re-execute from any step with the original (or modified) context
• 300+ Atomic Modules — composable building blocks for any workflow

flyto serve
# ✓ flyto-core running on 127.0.0.1:8333

curl -X POST localhost:8333/v1/workflow/run \
  -H 'Content-Type: application/json' \
  -d '{
    "workflow": {
      "name": "example",
      "steps": [
        {"id": "step1", "module": "string.uppercase", "params": {"text": "hello"}},
        {"id": "step2", "module": "string.reverse", "params": {"text": "world"}}
      ]
    },
    "enable_evidence": true,
    "enable_trace": true
  }'

# Step 3 failed? Replay from there.
curl -X POST localhost:8333/v1/workflow/{execution_id}/replay/step3

The engine loads the context snapshot at step 3 and re-executes from that point. No wasted computation.

name: Hello World
steps:
  - id: reverse
    module: string.reverse
    params:
      text: "Hello Flyto"

  - id: shout
    module: string.uppercase
    params:
      text: "${reverse.result}"

flyto run workflow.yaml
# Output: "OTYLF OLLEH"

import asyncio
from core.modules.registry import ModuleRegistry

async def main():
    result = await ModuleRegistry.execute(
        "string.reverse",
        params={"text": "Hello"},
        context={}
    )
    print(result)  # {"ok": True, "data": {"result": "olleH", ...}}

asyncio.run(main())

300+ atomic modules across 40+ categories, plus 28 third-party integrations.

Every module is automatically available as an MCP tool. Any MCP-compatible AI can discover, inspect, and execute all 300+ modules.

Claude ──┐
GPT    ──┤                    ┌─ browser.launch
Cursor ──┼── MCP Protocol ──→ ├─ string.reverse
Any AI ──┘                    ├─ file.read
                              └─ ... 300+ modules

Add to your MCP client config:

{
  "flyto-core": {
    "command": "python",
    "args": ["-m", "core.mcp_server"]
  }
}

# Core engine
pip install flyto-core

# With HTTP API server
pip install flyto-core[api]

# With browser automation
pip install flyto-core[browser]
playwright install chromium

# Everything
pip install flyto-core[all]

Run multi-step agent workflows with full evidence trail — every step's state captured, replayable, on disk.

Automate browsers with the browser.* module family (38 modules: launch, goto, click, extract, screenshot, etc.)

Chain API calls with built-in retry and error handling.

Build custom crm.*, billing.*, internal.* modules versioned in Git.

from core.modules.registry import register_module
from core.modules.schema import compose, presets

@register_module(
    module_id='string.reverse',
    version='1.0.0',
    category='string',
    label='Reverse String',
    description='Reverse the characters in a string',
    params_schema=compose(
        presets.INPUT_TEXT(required=True),
    ),
    output_schema={
        'result': {'type': 'string', 'description': 'Reversed string'}
    },
)
async def string_reverse(context):
    params = context['params']
    text = str(params['text'])
    return {
        'ok': True,
        'data': {'result': text[::-1], 'original': params['text']}
    }

See Module Specification for the complete guide.

flyto-core/
├── src/core/
│   ├── api/              # HTTP Execution API (FastAPI)
│   ├── modules/
│   │   ├── atomic/       # 300+ atomic modules
│   │   ├── composite/    # High-level composite modules
│   │   ├── patterns/     # Advanced resilience patterns
│   │   └── third_party/  # External integrations
│   └── engine/
│       ├── workflow/     # Workflow execution engine
│       ├── evidence/     # Evidence collection & storage
│       └── replay/       # Replay manager
├── workflows/            # Example workflows
└── docs/                 # Documentation

We welcome contributions! See CONTRIBUTING.md for guidelines.

Report security vulnerabilities via security@flyto.dev. See SECURITY.md for our security policy.

Source Available License — Free for non-commercial use.

See LICENSE for complete terms. For commercial licensing: licensing@flyto.dev

Deterministic execution engine for AI agents.
Evidence. Trace. Replay.