flyto-core

Flyto2 Core - Estrutura de Agentes de IA de Código Aberto e Mecanismo de Automação de Fluxos de Trabalho

O mecanismo de execução de código aberto para agentes de IA. 468 módulos, nativo MCP, gatilhos, fila, versionamento, medição.

flyto2.com · Automação em Nuvem · Documentação · Docs MCP · YouTube

Flyto2 Core é o runtime de código aberto por trás do Flyto2. Ele é construído para pessoas que querem uma estrutura de agentes de IA que realmente execute trabalho: automação de navegador, integração de API, raspagem web, automação de servidor MCP, receitas YAML reproduzíveis, captura de evidências e ferramentas determinísticas que agentes podem chamar sem inventar código não revisado.

Use-o quando a pergunta é simples, mas o trabalho é irritante: "abra esta página, capture a prova, extraia os dados, verifique o desempenho e deixe-me tentar novamente apenas a etapa com falha." Flyto2 Core oferece um mecanismo de execução local para automação de navegador, reprodução de fluxos de trabalho, chamadas de ferramentas de agentes de IA, verificações de Web Vitals, captura de capturas de tela, extração estruturada e evidências prontas para auditoria.

O inventário público atual é de 468 módulos apoiados por registro em 85 categorias de catálogo, incluindo gatilhos, módulos de fila, versionamento de fluxos de trabalho, ganchos de medição, automação de navegador, chamadas de API, transformações de dados, verificação, arquivos e criptografia.

Boa opção se você procurou por:

• estrutura de agentes de IA de código aberto para fluxos de trabalho de produção
• automação de fluxos de trabalho de IA em Python com Playwright
• automação de servidor MCP com rastreamento e reprodução
• automação de navegador que pode retomar de uma etapa com falha

Experimente em 30 segundos

pip install flyto-core[browser] && playwright install chromium
flyto recipe competitor-intel --url https://github.com/pricing

  Step  1/12  browser.launch         ✓      420ms
  Step  2/12  browser.goto           ✓    1,203ms
  Step  3/12  browser.evaluate       ✓       89ms
  Step  4/12  browser.screenshot     ✓    1,847ms  → saved intel-desktop.png
  Step  5/12  browser.viewport       ✓       12ms  → 390×844
  Step  6/12  browser.screenshot     ✓    1,621ms  → saved intel-mobile.png
  Step  7/12  browser.viewport       ✓        8ms  → 1280×720
  Step  8/12  browser.performance    ✓    5,012ms  → Web Vitals captured
  Step  9/12  browser.evaluate       ✓       45ms
  Step 10/12  browser.evaluate       ✓       11ms
  Step 11/12  file.write             ✓        3ms  → saved intel-report.json
  Step 12/12  browser.close          ✓       67ms

  ✓ Done in 10.3s — 12/12 steps passed

Capturas de tela capturadas. Métricas de desempenho extraídas. Relatório JSON salvo. Cada etapa rastreada.

O que acontece quando a etapa 8 falha?

Com um script de shell, você reexecuta tudo. Com flyto-core:

flyto replay --from-step 8

As etapas 1–7 são instantâneas. Apenas a etapa 8 é reexecutada. Contexto completo preservado.

3 receitas para experimentar agora

# Competitive pricing: screenshots + Web Vitals + JSON report
flyto recipe competitor-intel --url https://competitor.com/pricing

# Full site audit: SEO + accessibility + performance
flyto recipe full-audit --url https://your-site.com

# Web scraping → CSV export
flyto recipe scrape-to-csv --url https://news.ycombinator.com --selector ".titleline a"

Cada receita é rastreada. Cada execução é reproduzível. Veja todas as 41 receitas ->

Instalação

pip install flyto-core            # Core engine + CLI + MCP server
pip install flyto-core[browser]   # + browser automation (Playwright)
playwright install chromium        # one-time browser setup

O problema das 85 linhas

Veja como uma análise de preços competitiva se parece em Python:

import asyncio, json, time
from playwright.async_api import async_playwright

async def main():
    async with async_playwright() as p:
        browser = await p.chromium.launch()
        page = await browser.new_page()
        await page.goto("https://competitor.com/pricing")

        # Extract pricing
        prices = await page.evaluate("""() => {
            const cards = document.querySelectorAll(
              '[class*="price"]'
            );
            return Array.from(cards).map(
              c => c.textContent.trim()
            );
        }""")

        # Desktop screenshot
        await page.screenshot(
            path="desktop.png", full_page=True
        )

        # Mobile
        await page.set_viewport_size(
            {"width": 390, "height": 844}
        )
        await page.screenshot(
            path="mobile.png", full_page=True
        )

        # Performance
        perf = await page.evaluate("""() => {
            const nav = performance
              .getEntriesByType('navigation')[0];
            return {
              ttfb: nav.responseStart,
              loaded: nav.loadEventEnd
            };
        }""")

        # Save report
        report = {
            "prices": prices,
            "performance": perf,
        }
        with open("report.json", "w") as f:
            json.dump(report, f, indent=2)

        await browser.close()

asyncio.run(main())

name: Competitor Intel
steps:
  - id: launch
    module: browser.launch
  - id: navigate
    module: browser.goto
    params: { url: "{{url}}" }
  - id: prices
    module: browser.evaluate
    params:
      script: |
        JSON.stringify([
          ...document.querySelectorAll(
            '[class*="price"]'
          )
        ].map(e => e.textContent.trim()))
  - id: desktop_shot
    module: browser.screenshot
    params: { path: desktop.png, full_page: true }
  - id: mobile
    module: browser.viewport
    params: { width: 390, height: 844 }
  - id: mobile_shot
    module: browser.screenshot
    params: { path: mobile.png, full_page: true }
  - id: perf
    module: browser.performance
  - id: save
    module: file.write
    params:
      path: report.json
      content: "${prices.result}"
  - id: close
    module: browser.close

Visão Geral Atual da Plataforma

• Limite da estrutura de agentes de IA de código aberto: clientes compatíveis com MCP chamam módulos revisados do flyto-core por meio de esquemas, não código de produção gerado arbitrariamente.
• Substrato de automação de fluxos de trabalho de IA para automação de navegador, fluxos de trabalho de API, operações de dados/arquivos, chamadas de IA, notificações, verificação, rastreamento, evidências e reprodução.
• 468 módulos apoiados por registro em 85 categorias de catálogo. docs/TOOL_CATALOG.md é gerado a partir de ModuleRegistry, não contado manualmente.
• 41 receitas integradas para auditoria, automação de navegador, trabalho com dados/imagens, DevOps, integrações e verificação determinística.
• Módulos de verificação determinística (verification.* com aliases de compatibilidade warroom.*) suportam descoberta de grafo de site, geração de cenários de reprodução, evidências de execução e pacotes de relatórios.
• Acesso de saída e a arquivos endurecido na linha 2.26.x: clientes HTTP protegidos previnem bypass de SSRF, e gravações de arquivos/dados são confinadas através do guarda de caminho do sandbox.
• Execução reproduzível de navegador e fluxo de trabalho permanece o contrato central: cada passo pode produzir dados de rastreamento, instantâneos de evidência e reprodução direcionada a partir do ponto de falha.

Contrato de Nomenclatura Pública

• Use Flyto2 para a marca voltada ao produto e à empresa. Não use uma grafia legada abreviada em documentos públicos, exemplos ou textos de SEO.
• Use flyto2.com, docs.flyto2.com e blog.flyto2.com como superfícies de citação pública.
• Endereços de contato de exemplo públicos devem usar caixas postais registradas @flyto2.com como support@flyto2.com, security@flyto2.com, privacy@flyto2.com, sales@flyto2.com, team@flyto2.com, dev@flyto2.com, alerts@flyto2.com, oncall@flyto2.com, reports@flyto2.com, noreply@flyto2.com, dmarc@flyto2.com, conduct@flyto2.com, admin@flyto2.com, pentest@flyto2.com, hello@flyto2.com e info@flyto2.com.
• Documentos públicos, blog e páginas de destino devem citar os fatos centrais atuais acima em vez de contagens de módulos desatualizadas.

Recursos do Mecanismo

• Rastreamento de Execução — registro estruturado de cada passo: entrada, saída, tempo, status
• Reprodução — re-executar a partir de qualquer passo com o contexto original (ou modificado)
• Pontos de interrupção — pausar a execução em qualquer passo, inspecionar o estado, retomar
• Instantâneos de Evidência — estado completo antes e depois de cada limite de passo
• Linhagem de Dados — rastrear o fluxo de dados entre passos, construir gráficos de dependência
• Proteção de Tempo Limite — proteção configurável de tempo limite no nível do fluxo de trabalho e por passo

Arquitetura

CLI, MCP, HTTP, Python e receitas empacotadas convergem nos mesmos limites de mecanismo de fluxo de trabalho, registro de módulos, política, rastreamento, evidência e reprodução. Comece com o Whitepaper Técnico, depois use o Mapa de Arquitetura e a exaustiva referência de fonte para detalhes de implementação.

Configuração

O Core é configurado através de extras de pacote, argumentos de CLI, parâmetros de fluxo de trabalho, política de módulos, variáveis de ambiente e estado de execução local. Interruptores sensíveis à segurança de rede, sistema de arquivos, autenticação, callback e permissões são documentados em Configuração; todos os 107 leitores de ambiente detectados estão vinculados à fonte na referência de configuração gerada.

Extensões

O Core gerencia dois — e apenas dois — tipos de extensão instalável:

A admissão é apenas por prefixo e grupo de ponto de entrada, então um novo pacote como flyto-modules-robotics funciona no dia em que é publicado — nenhum código-fonte do Core nomeia qualquer extensão, e nenhum precisa mudar para uma.

export FLYTO_EXTENSIONS_INSTALL_ENABLED=1   # operator opt-in, off by default

curl -H "Authorization: Bearer $TOKEN" localhost:8333/v1/extensions
curl -X POST -H "Authorization: Bearer $TOKEN" \
     -H 'Content-Type: application/json' \
     -d '{"name": "flyto-modules-robotics"}' \
     localhost:8333/v1/extensions/install

Uma instalação só é relatada como bem-sucedida quando a distribuição instalada é provada a declarar um ponto de entrada no grupo do seu tipo; uma primeira instalação que falha nessa prova é revertida, uma atualização que falha é deixada no lugar para que o operador não fique sem nada. Atualizações e desinstalações relatam restart_required, porque o Python não pode desimportar código já carregado. Falhas retornam um código de erro estável e nunca a saída do gerenciador de pacotes. Veja API.

Referência de API / Módulos

468 Módulos, 85 Categorias de Catálogo

Veja o Catálogo Completo de Módulos para cada módulo, parâmetro e descrição.

Como isso é diferente?

Uso

# Run a built-in recipe
flyto recipe site-audit --url https://example.com

# Run your own YAML workflow
flyto run my-workflow.yaml

# List all recipes
flyto recipes

pip install flyto-core
claude mcp add flyto-core -- python -m core.mcp_server

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

pip install flyto-core[api]
flyto serve
# ✓ flyto-core running on 127.0.0.1:8333

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())

41 Receitas Integradas

Nenhum código necessário — cada receita é um modelo de fluxo de trabalho YAML:

flyto recipes                  # List all recipes

# Audit & Testing
flyto recipe full-audit       --url https://example.com
flyto recipe competitor-intel --url https://github.com/pricing
flyto recipe site-audit       --url https://example.com
flyto recipe web-perf         --url https://example.com
flyto recipe flyto2-ui-login-smoke --login_url https://myapp.com/login --page_url https://myapp.com/projects --username team@flyto2.com --password "$FLYTO_TEST_PASSWORD"
flyto recipe form-fill        --url https://myapp.com/form --data '{"email":"dev@flyto2.com"}'

# Browser Automation
flyto recipe screenshot        --url https://example.com
flyto recipe responsive-report --url https://example.com
flyto recipe page-to-pdf       --url https://example.com
flyto recipe visual-snapshot   --url https://example.com
flyto recipe webpage-archive   --url https://example.com
flyto recipe scrape-page       --url https://example.com --selector h1
flyto recipe scrape-links      --url https://example.com
flyto recipe scrape-table      --url https://en.wikipedia.org/wiki/YAML --selector .wikitable
flyto recipe stock-price       --symbol AAPL

# Data & Image
flyto recipe ocr               --input scan.png
flyto recipe csv-to-json       --input data.csv
flyto recipe image-resize      --input photo.jpg --width 800
flyto recipe image-convert     --input photo.png --format webp

# Network & DevOps
flyto recipe port-scan         --host example.com
flyto recipe whois             --domain example.com
flyto recipe monitor-site      --url https://myapp.com
flyto recipe docker-ps
flyto recipe git-changelog

# Integrations
flyto recipe scrape-to-slack   --url https://example.com --selector h1 --webhook $SLACK_URL
flyto recipe github-issue      --url https://example.com --owner me --repo my-app --title "Bug" --token $GITHUB_TOKEN

Cada receita é um modelo de fluxo de trabalho YAML. Execute flyto recipe <name> --help para opções completas. Veja docs/RECIPES.md para documentação completa.

Escreva Seus Próprios Fluxos de Trabalho

Receitas são apenas arquivos YAML. Escreva as suas:

name: price-monitor
steps:
  - id: open
    module: browser.launch
    params: { headless: true }

  - id: page
    module: browser.goto
    params: { url: "https://competitor.com/pricing" }

  - id: prices
    module: browser.evaluate
    params:
      script: |
        JSON.stringify([...document.querySelectorAll('.price')].map(e => e.textContent))

  - id: save
    module: file.write
    params: { path: "prices.json", content: "${prices.result}" }

  - id: close
    module: browser.close

flyto run price-monitor.yaml

Cada execução produz um rastreamento de execução e instantâneos de estado. Se o passo 3 falhar, reproduza a partir do passo 3 — sem re-executar tudo.

Para Autores de Módulos

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):
    text = str(context['params']['text'])
    return {'ok': True, 'data': {'result': text[::-1]}}

Veja Especificação de Módulos para o guia completo.

Contribuindo

Aceitamos contribuições! Veja CONTRIBUTING.md para diretrizes.

Testes

python -m pytest
python -m ruff check .
flyto recipe full-audit --url https://example.com

Segurança

Relate vulnerabilidades de segurança via security@flyto2.com. Veja SECURITY.md para a política de segurança e as variáveis de ambiente que definem os limites do sistema de arquivos e da rede de saída.

SECURITY_STATUS.md lista cada aviso publicado com sua gravidade, faixa afetada, versão corrigida e o teste de regressão que o cobre. Dois limites são aplicados em todo o registro por testes que falham na compilação — todo módulo que recebe um caminho fornecido pelo chamador deve alcançar o auxiliar de sandbox do sistema de arquivos, e todo módulo que recebe uma URL ou host fornecido pelo chamador deve alcançar um guarda de SSRF — então a cobertura é uma propriedade de CI, não uma convenção.

Licença

Apache License 2.0 — gratuito para uso pessoal e comercial.

Automação em Nuvem · Preços · flyto2.com

Implantação hospedada

Uma implantação hospedada está disponível no Frontier AI.