FLORA

A programmable
core for agents.

Act to get things done—and to find things out.

Flora selects actions to advance a task or reduce uncertainty about the next step. It derives local checks from observed tool results and how subsequent program steps use them. The General Agent brings this core to terminal-based research, documents, spreadsheets, and tool-connected work.

General Agent ↗Design principles ↓

PYTHON 3.11+APACHE-2.0EVIDENCE FIRST

FLORA / PIXEL PORTRAITF·01

OBSERVATION / EXECUTIONOBSERVE → GROW

ONE SYSTEM, DIFFERENT LAYERS

Agent, core, and research.

Explore the application, execution core,
and supporting research.

01 / APPLICATION

General Agent

A terminal-first agent for web research, documents, spreadsheets, and external tools. Resume conversations, delegate read-only subtasks, and inspect actual tool results and generated files.

Explore the general agent↗ 02 / EXECUTION

Flora Core

An execution engine that selects actions, records tool results, checks program revisions, and supports resumable execution.

Explore the core↗

03 / RESEARCH

Research & Paper

Design rationale, implementation details, and experimental evaluation. The paper is in preparation; architecture documentation is available.

IN PREPARATIONDesign notes ↗

DocumentationGUIDES & REFERENCE↗Source codeREAD THE IMPLEMENTATION↗ValidationTESTS & LIMITATIONS↗

THE DESIGN PHILOSOPHY

Action selection and
program revision.

01 Select actions that reduce uncertainty.

When candidate plans propose different next steps, Flora can select a diagnostic action to help distinguish them. A single action may contribute both to task progress and to information gathering.

Dual control

02 Derive checks from observed behavior.

Flora records tool outputs and how subsequent program steps use them. These observations provide the basis for local checks on program revisions. Insufficient evidence yields an unknown result.

Synthesizable contracts

Architecture and limitations ↗

Illustrative core pseudocodeExecution loopProgram model
FLORA CORE / EXECUTION LOOP · PSEUDOCODE
while within_budget(state):
    frontiers = advance_to_boundaries(state, ...)

    if revision_required(frontiers):
        guards = synthesize_local_guards(state.checks)
        revise_from_trace(state, guards, ...)
        continue

    if incumbent_returned(frontiers):
        return incumbent_result(frontiers)

    action = select_progress_or_diagnostic(frontiers, ...)
    receipt = execute_selected_effect(action, state)
    if outcome_unknown(receipt):
        return suspend_for_evidence(state)

    resume_matching_and_suspend_others(receipt, state)
    state.checks += check_observed_consumers(state, ...)

return incomplete(state)A shared execution trace informs action selection, local checks, and subsequent program revisions.Implementation ↗
FLORA CORE / PROGRAM MODEL · PSEUDOCODE
Program:
    entry: BlockId
    blocks: dict[BlockId, Block]
    ...

Block:
    params: list[Name]
    operations: list[PureOperation]
    terminator: Terminator

Terminator:
    Jump(target, args)
    Branch(condition, yes, no)
    Call(target, args, resume, captured, ...)
    Effect(tool, args, resume, captured, ...)
    Alternative(branches, join, captured, ...)
    Return(value)
    ...Explicit control flow separates pure computation, calls, alternatives, and external effects.Implementation ↗

Illustrative pseudocode; names and signatures are schematic. Validation, persistence, and recovery details are omitted. Contract checks apply to observed cases; insufficient evidence remains UNKNOWN.

Use the General Agent.

Install once, run flora in a working folder, and enter your model connection details.
Ask for research, document processing, or a report; inspect sources and tool results, then resume when needed.

Optional performance settings keep the same execution kernel. Model errors, response-time outliers, and network restrictions remain possible; completion is not proof of task success.

Get started ↗

A programmable core for agents.