Automation & Ops browser-automationmcp-serverplaywrightworkflow-enginereplayevidence-captureyaml-workflowsweb-scraping

Flyto2 Core

AI said it finished. Flyto2 shows the proof — a verified, replayable execution engine for AI agents.

FollowAgents review · FARS-2.1
Use with care
64/ 100 5-point scale 3.2 / 5
1 2 3 4 5 6
1Trust18 / 29 · 3.1/5

Trust: Docs declare a filesystem sandbox (FLYTO_SANDBOX_DIR) and SSRF guards (private ranges and cloud metadata blocked by default), with CI coverage tests forcing every path/URL module through the guard — a strong least-privilege design. Deduction: the sandbox defaults to the process working directory (self-described as rarely right for servers), and the guard implementation code itself is outside the supplied evidence. User confirmation: workflows are executed as code and can send notifications/write files, yet no pre-execution confirmation mechanism is described — only 'run workflows from trusted sources' — score 1. Data flow transparency: execution traces, evidence snapshots, and data lineage are concretely described. Sensitive data: SECURITY.md prescribes ${env.API_KEY} patterns, log redaction, and file permissions; the redaction mechanism itself is not shown in code. Dependency security: pyproject dependency floors carry GHSA IDs and rationale comments (interruptible regex, Pillow ACE fix, pytest tmpdir); CI runs pip-audit and npm audit with lockfile drift checks — full marks. External effects: SSRF guard with per-redirect revalidation and DNS-rebinding protection is concretely described; but browsers execute arbitrary page JS and port.check can be explicitly enabled — boundaries are disclosed, not removed. Rollback: 'replay --from-step N' with state snapshots is the core pitch (score 2), but no undo for produced artifacts like file.write. Source attribution: only 'Flyto2 Team <[email protected]>' with an unverified publisher; no governance or backing entity — score 1.

2Reliability9 / 14 · 3.2/5

Reliability: Self-consistency is good — README, SECURITY.md, pyproject (2.32.0, py3.10 floor with rationale), and CI agree, including candid correction of past errors (uninstallable 3.9 floor; Playwright 1.40 floor causing TypeError). Deduction: the 480-module/88-category/41-recipe counts cannot be item-checked from the provided files. Dependency availability: optional extras are cleanly grouped and requirements.txt delegates to pyproject; but very recent floors (aiohttp>=3.14.3) may block older distributions with no fallback documented. Failure messages: modules return structured {'ok': False, 'error_code': 'SSRF_BLOCKED'} and traces record per-step status; examples are ample but real error paths are unexecuted.

3Adaptability10 / 18 · 2.8/5

Adaptability: Audience and scenarios are clear (developers, CI, MCP clients) with CLI/MCP/HTTP/Python entry points. Capability boundaries: the 'Known Security Considerations' section candidly discloses code-execution, network, and browser risks and advises isolation — score 2; but the 480-module surface (cloud/k8s/AWS) is not itemized. Trigger precision: only communication.webhook_trigger is glimpsed; trigger behavior, dedup, auth are nearly absent from evidence — score 1. Environment fit: py3.10–3.13 declared and verified per-version in a CI matrix; headless defaults and FLYTO_VSCODE_LOCAL_MODE show deployment awareness.

4Convention14 / 18 · 3.9/5

Convention: Information architecture is excellent — README links RECIPES, TOOL_CATALOG, CONFIGURATION, PLUGIN_SDK, MODULE_SPECIFICATION, WHITEPAPER, ARCHITECTURE, plus an mcp-name annotation — full marks. Install notes: three extras, playwright install chromium, a 30-second example — full marks. Naming stability: prefixed module namespaces with a CI brand-identity check, but package name flyto-core vs import name core is a mild inconsistency. Examples: three recipes, YAML workflow, and Python API examples; no FAQ. Known limitations: support table (only 2.32.x), honest dependency-floor rationale, and CI's explanation of excluded browser tests; no standalone limitations doc. License: full Apache-2.0 text present and consistent — full marks. Versioning: 2.32.0 consistent across files, CI release-drift check, CHANGELOG linked but its content is not in evidence. Maintenance: CONTRIBUTING, maintainer fields, 48-hour response commitment; single team, no external maintainers — score 2.

5Effectiveness9 / 13 · 3.5/5

Effectiveness: Output usability — structured traces, JSON reports, screenshots, and output_schema on composite modules give clear output contracts. Marginal value: replay-from-step plus per-step traces is a genuine differentiator vs raw Playwright/scripts, with a concrete comparison table; but the claim rests entirely on documentation — no execution was performed in this review. Cost-benefit: single pip install, opt-in extras, module reuse reduce glue code; however, a 480-module surface is a large audit/maintenance burden whose long-term cost is not discussed.

6Verifiability4 / 8 · 2.5/5

Verifiability: Claim traceability — '480 modules', '41 recipes', and the fail-the-build coverage tests point at concrete files (tests/core/test_write_sink_coverage.py, security/advisories.), but most referenced files were not supplied, so claims can only be checked for internal consistency, not against artifacts — score 1. Cross-source corroboration: README, SECURITY.md, pyproject, and CI mutually confirm versions, boundaries, and dependency rationale — strong internal agreement, but all from one publisher with no independent verification (MseeP badges are self-declared) — score 1. Fact/inference separation: pyproject comments clearly separate 'what the historical error was' from 'what the current choice is', CI comments justify each exclusion, and marketing slogans are visually distinct from factual claims — score 2.

Evidence confidence: Low Reviewed Sep 08, 2026 Reviewed revision e5e4c0a53ade
Before you use it
  • The sandbox defaults to the process working directory; server deployments must set FLYTO_SANDBOX_DIR explicitly or caller-supplied relative paths resolve against an arbitrary location.
  • Workflow files are executable code and no pre-execution confirmation or signing mechanism is provided — never run untrusted YAML workflows.
  • Flags such as FLYTO_ALLOW_PRIVATE_NETWORK, FLYTO_ALLOW_PORT_SCAN, and FLYTO_ALLOW_REMOTE_OLLAMA materially widen the network attack surface; keep them off by default in production.
  • The '480 modules / 88 categories / 41 recipes' figures and CI coverage-test claims could not be item-verified in this static review; treat them as documentation claims, not verified facts.
  • Publisher identity is unverified; [email protected] and the MseeP badges are self-reported — perform independent supply-chain verification before enterprise adoption.
See the full review method →

What does this agent do, and when should you use it?

Flyto2 Core is the open-source runtime behind Flyto2 (GitHub: flytohub/flyto-core, Apache-2.0), positioned as an execution engine for AI agents. It ships as a Python package exposing a CLI, an MCP server, and an HTTP API, all converging on the same workflow engine, module registry, policy, trace, evidence, and replay boundaries. The current public inventory covers 480 registry-backed modules across 88 catalog categories and 41 built-in YAML recipes spanning browser automation, API calls, data transforms, verification, files, and crypto. Its core contract is deterministic execution: every step produces trace data and evidence snapshots, and a failed step can be replayed in isolation with flyto replay --from-step N instead of rerunning the whole workflow. It is one of three independently usable packages — flyto-ai and flyto-blueprint handle governance and procedure learning, while this package alone validates, executes, and emits evidence.

Flyto2 Core reads YAML workflow files, executes modules from its module registry step by step, and records a structured Execution Trace with input, output, timing, and status for each step. It captures Evidence Snapshots at every step boundary, and supports Breakpoints, Data Lineage, and a Timeout Guard at workflow and per-step levels. Through the MCP server (python -m core.mcp_server), MCP clients such as Claude Code, Cursor, and Windsurf can call all 480 modules as tools. Through the HTTP API (flyto serve, default 127.0.0.1:8333), endpoints include POST /v1/workflow/run, POST /v1/workflow/{id}/replay/{step}, POST /v1/execute, GET /v1/modules, and POST /mcp. Browser capability is built on Playwright (pip install flyto-core[browser], then playwright install chromium); built-in recipes like competitor-intel capture screenshots, Web Vitals, structured extractions, and write JSON reports. Extensions are limited to two kinds — flyto-modules-* module packs and flyto-plugin-* plugins — and installation requires the operator to opt in via FLYTO_EXTENSIONS_INSTALL_ENABLED=1.

  1. Engineers who must prove to a team or auditor that an AI agent actually completed its work: every run yields traces, evidence snapshots, and reports rather than only the model's claim.
  2. Operations staff running competitor price monitoring or site audits: recipes like competitor-intel and full-audit deliver screenshots, performance metrics, and JSON reports in one command.
  3. Developers maintaining long workflows: when step 8 fails, flyto replay --from-step 8 resumes from the failure point without rerunning steps 1–7.
  4. Users of Claude Code, Cursor, or Windsurf: the MCP server exposes all 480 reviewed modules as deterministic tools, avoiding agents generating unreviewed production code.
  5. QA testers who need debuggable browser automation: the 54-module browser.* family offers per-step timing, state inspection, and replay from failure.
  6. Platform teams building internal automation services: start flyto-core[api] and integrate evidence and trace through /v1/workflow/run.

What are this agent's strengths and limitations?

Pros
  • Deterministic replay is the core differentiator: failed steps replay in isolation (flyto replay --from-step 8) with steps 1–7 restored instantly, unlike script-based tools that rerun everything.
  • Evidence and tracing are built into the runtime: structured per-step input/output/timing/status traces, state snapshots at step boundaries, and data lineage make outputs audit-ready.
  • MCP-native: AI clients call schema-reviewed modules instead of executing arbitrary model-generated production code, reducing uncontrolled-code risk.
  • Boundaries are enforced in CI: caller-supplied paths must reach the filesystem sandbox helper and caller-supplied URLs/hosts must reach an SSRF guard, backed by tests that fail the build; SECURITY_STATUS.md lists every published advisory with severity, affected range, and fixed-in version.
Limitations
  • Browser capability depends on extra Playwright and Chromium installation steps (pip install flyto-core[browser] && playwright install chromium) and is not available by default.
  • Scope is deliberately narrow: intent/provider governance, procedure learning and scoring, and hosted product logic live in flyto-ai and flyto-blueprint; teams wanting the full product need the other two packages.
  • The extension mechanism has runtime constraints: upgrades and uninstalls report restart_required (Python cannot un-import loaded code), and extension installation is off by default, requiring FLYTO_EXTENSIONS_INSTALL_ENABLED=1.
  • The hosted deployment is offered only via Frontier AI (fronteir.ai), and official cloud automation is a paid product (pricing at flyto2.com/cloud/), so beyond self-hosting the paths depend on third-party platforms.

How do you install or deploy this agent?

Requires Python 3.10+. Base install: pip install flyto-core (core engine + CLI + MCP server). For browser automation: pip install flyto-core[browser] && playwright install chromium (one-time setup). For the HTTP API: pip install flyto-core[api]. Verify with: flyto recipe competitor-intel --url https://github.com/pricing.

How do you use this agent?

CLI: flyto run my-workflow.yaml runs your YAML workflow; flyto recipes lists all 41 recipes; flyto recipe site-audit --url https://example.com runs a built-in recipe; on failure, flyto replay --from-step 8 replays from step 8. MCP: run claude mcp add flyto-core -- python -m core.mcp_server, or add {"mcpServers": {"flyto-core": {"command": "python", "args": ["-m", "core.mcp_server"]}}} to your MCP config so your AI client can call all 480 modules. HTTP API: flyto serve listens on 127.0.0.1:8333 by default; call POST /v1/workflow/run, POST /v1/execute, etc. Python API: from core.modules.registry import ModuleRegistry, then await ModuleRegistry.execute("string.reverse", params={...}, context={}). Author custom modules with the @register_module decorator, specifying module_id, params schema, and output schema.

How does this agent compare with similar options?

The README directly compares flyto-core with Playwright/Selenium and shell scripts: when step 8 fails, the latter two rerun everything and require manual print/echo debugging, while flyto-core replays from any step with a full trace; browser + API + file I/O requires glue code or three languages in the alternatives but is built in; in CI, the alternatives need fragile pytest/bash wrappers, while flyto-core runs flyto run workflow.yaml.

FAQ

Does it need network access? Can it run offline?
Browser automation, API calls (http.*, api.*), and site monitoring recipes require network access, subject to the SSRF guard boundary. Purely local modules (string.*, file.*, image.*, crypto.*) work offline.
Step 8 failed — do I have to rerun the whole workflow?
No. flyto replay --from-step 8 restores the context of steps 1–7 instantly and re-executes only step 8. Breakpoints also let you pause at any step, inspect state, and resume.
How is filesystem and outbound network access secured?
Two boundaries are enforced registry-wide by build-failing tests: modules taking a caller-supplied path must reach the filesystem sandbox helper, and modules taking a caller-supplied URL or host must reach an SSRF guard. The 2.26.x line hardened HTTP clients against SSRF bypasses. Report vulnerabilities to [email protected]; published advisories are listed in SECURITY_STATUS.md.
Can I extend it? How do I install third-party module packs?
Yes. Extensions must use the flyto-modules-* (module packs) or flyto-plugin-* (plugins) prefixes, validated via the flyto.modules / flyto.plugins entry-point groups. Installation is off by default — set FLYTO_EXTENSIONS_INSTALL_ENABLED=1 and call /v1/extensions/install; an install only succeeds if the distribution proves it declares a valid entry point, otherwise it is rolled back.
Is there a hosted version besides self-hosting? What does it cost?
Yes. Flyto2 offers a cloud automation service (flyto2.com/cloud/, pricing at flyto2.com/pricing/) and a hosted deployment on the Frontier AI platform. The core engine itself is free for personal and commercial use under the Apache-2.0 license.

Compare agents like this one

The same FARS review applied across the shortlist this agent qualifies for.

Related agents