Ephemora Cell

A camada de execução para código gerado por IA não confiável.

Execução WASM rápida e baseada em capacidades, com limites explícitos de CPU, memória, tempo, I/O e sistema de arquivos — execução aquecida em sub-milissegundos com registros de execução assinados.

Construído para agentes de IA, ferramentas MCP, plugins, interpretadores de código e outras cargas de trabalho não confiáveis.

O problema

Agentes de IA precisam cada vez mais escrever e executar código, chamar ferramentas e rodar plugins. A questão que decide se isso é seguro:

Como você permite que um agente execute código não confiável sem dar a esse código acesso ao seu host, às suas credenciais, à sua rede ou a computação ilimitada?

Agente de IA ──▶ Ferramenta / MCP ──▶ Ephemora Cell ──▶ WASM ──▶ resultado limitado

Ephemora Cell é um runtime de execução WASM pequeno e baseado em capacidades, exatamente para essa função: um primitivo de execução — não um framework de agentes — que fica abaixo da sua pilha de agentes existente, servidor MCP, sistema de plugins ou aplicação.

Início Rápido

pip install ephemora-cell

# Execute seu primeiro módulo isolado (pegue os exemplos do repositório ou traga qualquer .wasm):
git clone https://github.com/MichaelS1011/ephemora-cell.git
ephemora-cell run ephemora-cell/examples/hello.wasm

Hello from Ephemora Cell!

from ephemora_cell import run_wasm

result = run_wasm("my_module.wasm")
print(result.stdout)          # saída capturada (limite de 10 KB)
print(result.status.name)     # SUCCESS
print(result.elapsed_ms)      # tempo de parede
print(result.fuel_consumed)   # computação realmente utilizada

Sessão real de CLI: instalação, primeira execução, relatório --json legível por máquina com a linha de base de segurança, e um módulo de ataque (exploit.wasm) bloqueado na camada de importação WASI. Verifique cada quadro: os comandos são executados como mostrado a partir de um clone.

As mesmas oito primitivas de ataque, medidas ao vivo em uma única execução (2026-09-02): um contêiner padrão python:3.12-slim permite todas (0/8 bloqueadas), a fronteira do Ephemora Cell bloqueia todas as oito (8/8). Reproduza ambas as colunas:

python3 assets/demo_attack_probe.py    # coluna esquerda  -> 0/8 bloqueadas (Docker padrão)
python  benchmarks/verify_8_vectors.py # coluna direita -> 8/8 bloqueadas (Ephemora Cell)

Por que isso importa

Código gerado por agente é diferente de código de aplicação: pode ser bugado, computacionalmente ilimitado, inesperadamente caro — ou hostil. O runtime deve impor fronteiras, não documentá-las. Cada execução do Cell faz:

• Imposto, não prometido — medição de combustível (CPU), limites de memória, timeouts de tempo de parede baseados em época, limites de saída e orçamentos de I/O são impostos por execução; a postura efetiva é atestada em um registro de execução assinado.
• Vantagem de isolamento medida — dos vetores de ataque que têm sucesso contra um contêiner Docker padrão (shell, fork, socket, sistema de arquivos do host, escape de symlink, …), todos os 8 são bloqueados aqui (verificado ao vivo, script no repositório).
• Execução aquecida em sub-milissegundos — 0,16 ms convidado / 0,46 ms ponta a ponta (com pool, medido) torna o sandboxing de cada chamada acessível em vez de excepcional.

O que é imposto

Cada execução roda sob limites explícitos — sem segurança opcional:

Controles adicionais: orçamentos de I/O (io_cpu_seconds=2.0 / io_budget_bytes=64 MiB — paredes para trabalho do host, não apenas computação do convidado), ABI dupla (WASI Preview1 + componentes WASI 0.2, opt-in), memory64 opt-in, limite declarado de heap GC (registrado na linha de base de segurança; o combustível permanece como o limite efetivo), estado nomeado (64 entradas · 256 KiB · 1 MiB por sessão) e um mediador de referência sidecar de egresso (chamadas de API do lado do host validadas por allowlist — docs/egress_patterns.md).

Segurança

O convidado recebe apenas as capacidades explicitamente disponibilizadas a ele. Verificação ao vivo de oito classes de ataque (benchmarks/verify_8_vectors.py):

Resultado: 8/8 vetores de ataque bloqueados (verificado ao vivo); as linhas de base do Docker são medidas ao vivo por execução — nunca codificadas.

Esta é uma fronteira de execução, não uma afirmação de que o software convidado é confiável. O Cell não avalia se um módulo é malicioso ou correto — um convidado ainda pode se comportar mal dentro dos orçamentos que recebeu. Os caminhos de execução diferem materialmente: o padrão executa o convidado dentro do seu processo; run_isolated() adiciona paredes no nível do SO (rlimits, cota de disco, watchdog de CPU de I/O, kill forçado).

Detalhes completos: SECURITY.md (política, matriz de controle de caminhos de execução, limitações conhecidas) · docs/threat-model.md (modelo de adversário, fronteiras de confiança, riscos residuais) · docs/security_posture.md (avaliação arXiv 2509.11242, fronteira de combustível, pesquisa relacionada).

Desempenho

Coloque cada execução em sandbox sem pagar custos de inicialização em escala de contêiner.

Comparação ao vivo de cold-start (2026-08-30, mesmo Mac): docker run python:3.12-slim 171 ms vs Cell 0,40 ms = 427× — esta é uma comparação de cold-start de contêiner vs WASM invocado para esta carga de trabalho de benchmark, não uma afirmação geral de que WASM é sempre mais rápido que Docker.

Reproduza: python benchmarks/pool_vs_budget.py · python benchmarks/competitive_benchmark.py (resultados brutos com measured:true commitados sob benchmarks/results/). Cargas de trabalho agênticas e mais: docs/performance.md.

Qualquer linguagem que compile para WASM

O Cell executa o .wasm — ele não conhece a linguagem de origem. Build em um comando com dicas de erro acionáveis a partir da matriz de fricção medida:

ephemora-cell build tool.rs     # → tool.wasm → execute-o

Todos os cinco portões de linguagens compiladas verificam a cada push (.github/workflows/ci.yml). Plataformas: macOS (Apple M5) ✅ · Ubuntu 24.04 ✅ · DGX Spark GB10 ✅

Casos de Uso

Código gerado por IA — execute ferramentas produzidas por agentes com limites explícitos:

result = run_wasm(
    "llm_generated.wasm",
    max_fuel=200_000,
    timeout_seconds=5,
    allow_dirs=("/input", "/output")
)

Sistemas de plugins — aceite plugins enviados por usuários sem dar a eles acesso irrestrito ao host:

config = WASIConfig(allow_dirs=("/data",), max_fuel=500_000)
result = WASISandbox(config=config).run("user_plugin.wasm")

Também documentado: cargas de trabalho serverless/edge, validação em ambiente isolado, componentes WASI 0.2, integração FastAPI — docs/recipes.md. Testes de integração com frameworks de agentes (LangGraph, CrewAI, AutoGen, OpenAI Agents SDK, Semantic Kernel, Hermes, NemoClaw) estão em integration/.

Servidor MCP

O Ephemora Cell inclui um servidor MCP stdio sem dependências cujas ferramentas são módulos WASM executados dentro do Cell — determinismo, medição de combustível, limite de saída, sem rede, registros de execução assinados prontos para SEP-2787:

pip install ephemora-cell
ephemora-cell-mcp          # ferramenta echo incluída; registre a sua: --tools-dir ./tools

Veja docs/mcp.md e docs/comparison-mcp-servers.md.

Arquitetura

flowchart TB
    guest["Módulo WASM Convidado<br/>(isolado)"]
    subgraph sandbox["Sandbox WASI — isolamento baseado em capacidades"]
        fuel["Medidor de Combustível<br/>~13 combustível/iteração"]
        mem["Limite de Memória<br/>128 MB máx"]
        timeout["Guarda de Timeout<br/>interrupção por época"]
        syscalls["WASI Preview1 — baseado em capacidades,<br/>apenas diretórios preabertos<br/>fd_read · fd_write · path_open · clock_time_get<br/>proc_exit · environ_get · random_get"]
    end
    blocked["Bloqueado por design:<br/>exec · fork · socket · /dev · /proc · /sys · threads"]

    guest --> syscalls
    fuel -.-> sandbox
    mem -.-> sandbox
    timeout -.-> sandbox
    sandbox -.-> blocked

A API primária é deliberadamente simples: execute(wasm) → result. Cada execução retorna informações estruturadas e auditáveis:

result.status        # SUCCESS | ERROR | TIMEOUT | FUEL_EXHAUSTED | MEMORY_EXCEEDED
result.exit_code
result.stdout        # limite de 10 KB
result.stderr
result.elapsed_ms
result.fuel_consumed

Isso torna a execução adequada para auditoria, imposição de políticas e contabilização de recursos — não apenas para executar código. CLI completa (run, --json com security_baseline, inspect, benchmark, build, perfis incl. --profile analytical) na documentação da CLI e em ephemora-cell --help.

O que o Cell é — e não é

O Cell é: um primitivo de execução WASM · uma camada de isolamento baseada em capacidades · um runtime com limites de recursos · uma biblioteca Python incorporável · uma CLI · uma camada de execução MCP.

O Cell não é: um framework de agentes · um LLM · um sistema de geração de código · um detector de malware · uma VM completa · um substituto para toda carga de trabalho em contêiner.

O objetivo é estreito: tornar a execução não confiável barata o suficiente e controlada o suficiente para que uma aplicação possa fazê-la com segurança por padrão.

Testes e Verificação

379 testes · 85% de cobertura de declarações (Cell + MCP, portão de 80%) · 8/8 vetores de ataque bloqueados · imposto por CI a cada push (testes, cobertura, pip-audit, SBOM, bandit) — veja .github/workflows/ci.yml.

Documentação

SECURITY.md — política e controles de segurança · docs/threat-model.md — fronteiras de confiança · docs/security_posture.md — verificação de superfície de ataque · docs/performance.md — benchmarks · docs/mcp.md — servidor MCP · docs/recipes.md — padrões de uso · docs/languages.md — suporte a linguagens · CHANGELOG.md — alterações

Sobre a Ephemora

O Ephemora Cell é a camada de isolamento de código aberto (Apache 2.0, independente — sem dependência da Ephemora). A edição enterprise da Ephemora se baseia no isolamento do Cell para implantações de produção e regulamentadas. O Cell é completo para isolamento; a edição enterprise é completa para operação — veja docs/enterprise.md para quando essa conversa vale a pena.

Licença

Apache 2.0 — Veja LICENSE.

Uma ação de agente. Uma execução limitada. Um resultado controlado.

Criado por Michael Soppa.