OpenProgram

"The more constraints one imposes, the more one frees oneself." — Igor Stravinsky, Poetics of Music

We propose Agentic Programming. An LLM is flexible; code is deterministic. Let the model run everything and you get chaos — unpredictable execution, context explosion, no output guarantees; hard-code everything and you lose the intelligence. A harness balances the two, interleaved moment to moment — Python for the flow you want fixed, the LLM for the judgement you can't script. (the full rationale →)

🎉 Paper: LLM-as-Code: Agentic Programming for Agent Harness — accepted at the KDD 2026 Workshop on Agentic Software Engineering (AgenticSE).

News

• 2026-07-21 — v0.6.0 — multi-agent collaboration: spawn N sub-agents, message them across sessions, run file-touching branches in isolated git worktrees.
• 2026-06-22 — Paper accepted at the KDD 2026 Workshop on Agentic Software Engineering (arXiv:2606.15874).
• 2026-06-07 — v0.5.0 — installable harnesses (openprogram programs install <owner>/<repo>), one-command install on every platform, multi-account providers with automatic key rotation, and the rescue / doctor diagnostics.
• 2026-05-28 — v0.4.0 — the design-system foundation behind the web UI and TUI.
• 2026-04-04 — v0.3.0 — built-in Anthropic / OpenAI / Gemini providers.
• 2026-04-03 — v0.1.0 — first release: the @agentic_function decorator and the execution DAG.

What makes it different

Multi-platform, multi-provider, multi-channel — table stakes; OpenProgram has them (macOS / Linux / Windows, any LLM, terminal / browser / chat). What sets it apart are four mechanisms in the harness itself — one primitive and the three things it unlocks, each the foundation for a class of agent you can build on top.

① Agentic Function — the primitive everything else is built on

An agent is a Python function — the same triage agent, written both ways:

TRIAGE_PROMPT = """You are a triage
agent. Classify the ticket as bug,
feature, or question. Reply as JSON."""

TOOLS = [{"type": "function", "function": {
  "name": "triage",
  "parameters": {"type": "object",
    "properties": {"ticket": {"type": "string"}},
    "required": ["ticket"]}}}]

resp = client.chat(TRIAGE_PROMPT, tools=TOOLS)
kind = json.loads(resp)["kind"]     # hope it parses
if kind not in ("bug", "feature"):
    ...                             # and re-prompt by hand

@agentic_function
def triage(ticket: str, runtime=None) -> str:
    """Classify the ticket as bug / feature /
    question, then draft a reply."""
    kind = runtime.exec(                    # 🤖 LLM decides
        ticket, choices=["bug", "feature", "question"])
    if kind == "bug":                       # 🐍 you decide
        logs = search_logs(ticket)          # 🐍 plain Python
        return runtime.exec(                # 🤖 LLM writes
            f"Reply using:\n{logs}")
    return runtime.exec("Draft a short reply.")

🤖 runtime.exec() = the LLM call — one retryable DAG node 🐍 everything else = plain Python, runs every time

docstring = the prompt · type annotations = the tool schema · choices=[...] = a code gate that re-asks until the answer is valid. Same behavior as the left column, with no prompt template and no tool JSON.

② DAG Context — for native multi-agent systems

Context is an addressable node, not a per-agent buffer — so every multi-agent move is just "point at a different node set":

③ Agentic Workflow — for trustworthy & self-evolving agents

A code gate can't be talked past. When the model's answer fails validation, it is sent back to re-decide — this is the real transcript:

llm  → "probably a feature request"
gate ✗ no parseable pick from ["bug", "feature", "question"]
llm  → {"call": "feature"}
gate ✓ → branch taken in Python

And it grows itself: the agent edits its own @agentic_function files with ordinary file tools → a watcher hot-loads them → the new tool is live on the next turn. No create() / fix() machinery.

④ Event Infrastructure — for proactive agents

One bus, every subsystem. The agent loop, auth, context, channels, and memory all emit the same Event(type, payload, ts) envelope, so anything can watch anything:

from openprogram.events import get_event_bus

get_event_bus().subscribe(                       # returns an unsubscribe fn
    lambda e: alert(e.payload),
    types={"context.compaction_recommended", "file.changed"},
)

A foundation, honestly labelled: the plumbing is in place and the proactive policy layer is its first intended consumer — that part is yours to build.

Quick Start

1. Install

macOS / Linux:

curl -fsSL https://raw.githubusercontent.com/Fzkuji/OpenProgram/main/scripts/install.sh | bash

Windows (PowerShell):

iwr -useb https://raw.githubusercontent.com/Fzkuji/OpenProgram/main/scripts/install.ps1 | iex

More options — flags, unattended / AI-agent install, installing from a checkout: docs/install/install.md.

2. Run

openprogram

First run sets up your provider, then asks which surface to open. Skip the prompt with openprogram tui (terminal) or openprogram web (browser → http://localhost:18100).

3. Add a harness

Harnesses are programs under openprogram/functions/agentics/. Anything cloned into that folder auto-registers on the next worker restart — that's the universal way any program (including your own) plugs into OpenProgram. Pure-Python harnesses also have a one-line shortcut, openprogram programs install <name>, which clones them there for you.