Pular para o conteúdo
Phronesis v0.1.0 alfa está disponívelLer o anúncio
Phronesis

Código aberto · Apache 2.0 · Python 3.11+

Sabedoria prática para sistemas de agentes de IA.

Phronesis (φρόνησις): para Aristóteles, sabedoria prática — a capacidade de deliberar bem e agir com discernimento em situações concretas. Um LLM tem episteme (conhecimento). Um agente precisa de phronesis.

hello_phronesis.py
from phronesis import Agent, anthropic

researcher = Agent(
    name="researcher",
    model=anthropic("claude-opus-4-7"),
    system_prompt="You investigate questions thoroughly and cite sources.",
)

answer = await researcher.run("What is phronesis in Aristotelian ethics?")

Por que Phronesis

Um agente não é um chatbot com ferramentas.

Os LLMs sabem coisas — isso é episteme. Mas os agentes precisam decidir e agir com discernimento em situações concretas. Isso é phronesis. A maioria dos frameworks de agentes os trata como chatbots aprimorados colados a um laço de uso de ferramentas. Phronesis os trata como sistemas deliberativos com contratos explícitos: entradas tipadas, efeitos declarados, memória delimitada, padrões de execução nomeados.

Frameworks existentes forçam uma escolha. De um lado, você escreve fluxo de controle arbitrário como código: expressividade máxima e um sistema multiagente que ninguém consegue depurar seis meses depois. Do outro, tudo é descrito em YAML ou construtores de grafos: legível à primeira vista, impossível assim que você precisa de algo não trivial. Phronesis separa a especificação declarativa da execução em tempo de execução. Agentes, ferramentas, memória, pipelines são specs tipadas, imutáveis, serializáveis em JSON. Os padrões de execução vêm de um catálogo fechado e bem definido — expressividade sem caos.

Cada execução é observável via OpenTelemetry, cada spec é versionável, cada contrato é uma verificação em tempo de execução, não um comentário num prompt. Essa é a diferença entre um framework que produz demos e um que produz sistemas que você pode operar.

Tour pelo código

A API em quatro trechos.

Python de verdade. Forma real. O framework abaixo está em alfa inicial — a superfície vai crescer, mas o design vai continuar enxuto.

Um agente vincula um modelo, ferramentas e memória sob uma única spec declarativa.

agent.py
from phronesis import Agent, anthropic
from phronesis.memory import SemanticMemory

agent = Agent(
    name="assistant",
    model=anthropic("claude-opus-4-7"),
    tools=[search_web, read_file],
    memory=SemanticMemory(scope="session"),
    system_prompt="You are a careful research assistant.",
)

Padrões

Projetado para as formas de agente que se repetem.

Estes são padrões que o framework suporta hoje. Não são estudos de caso — ainda não temos usuários em produção para reivindicar, e não vamos fingir o contrário.
  • Agentes de pesquisa

    Agentes que reúnem informações, raciocinam sobre elas e sintetizam respostas com citações.

  • Agentes de documentos

    Agentes que leem, estruturam e agem sobre documentos com memória explícita do que viram.

  • Pipelines multiagente

    Pipelines que compõem agentes especializados via repasses, debate ou consenso.

  • Assistentes com ferramentas

    Agentes que invocam ferramentas tipadas e servidores MCP sob contratos de segurança explícitos.

Princípios

Seis escolhas, aplicadas em todo lugar.

  • Composição em vez de herança

    Agentes são configurados a partir de partes — modelo, ferramentas, memória, prompts — não subclassificados. Você monta; não sobrescreve.

  • Async primeiro

    Streaming, concorrência e cancelamento são premissas básicas. Não há API síncrona paralela para manter.

  • Fortemente tipado

    Pydantic v2 em tudo. Tipos não são documentação — são contratos em tempo de execução que o framework faz cumprir.

  • Specs imutáveis, execuções mutáveis

    Definições são serializáveis em JSON e reproduzíveis. O estado de execução vive à parte, observável e consultável.

  • Observabilidade embutida

    Spans do OpenTelemetry para cada execução de agente, chamada de ferramenta e etapa de pipeline — desde o primeiro commit, não parafusados depois.

  • Catálogo fechado de padrões de execução

    Sequence, Parallel, ReActLoop, Consensus, Debate, Handoff. Modos nomeados sobre os quais se pode raciocinar — não fluxo de controle arbitrário.

O que tem dentro

Uma superfície pequena e com princípios.

O framework é intencionalmente estreito. Cada camada ganha seu lugar tornando um sistema mais seguro de operar ou o código mais fácil de ler seis meses depois.

Núcleo

As primitivas a partir das quais cada agente é construído.

  • Agentes
  • Ferramentas
  • Integração com MCP
  • Prompts
  • Capacidades

Estado e contexto

Como agentes se lembram e o que compartilham.

  • Memória (episódica, semântica, de trabalho, compartilhada)
  • Gestão de contexto
  • Sessões

Orquestração

Como agentes se compõem em sistemas.

  • Pipelines
  • Modos de execução
  • Comunicação entre agentes
  • Políticas
  • Observabilidade

Instalar

Um comando. Python 3.11 ou superior.

$pip install phronesis-framework

Status do projeto

Phronesis está em alfa inicial.

A API vai mudar. Estamos trabalhando em público para construir um framework que leva sistemas de agentes a sério — tipado, componível, observável. Sem afirmações de produção, sem estudos de caso fabricados, sem barreiras corporativas. Apenas o código e um compromisso honesto com seu design.

Feedback, ideias e contribuições são bem-vindos via GitHub Discussions e Issues. O roteiro, as arestas e as perguntas em aberto estão todos no repositório.