README.md

August 24, 2026 · View on GitHub

OpenProgram

OpenProgram: Self-Programming AI Agent Framework
Agents create and refine their own workflows · Any LLM · macOS and Linux releases

arXiv Release License Python Platforms Build status

Getting Started · Install · Self-Programming Agents · Framework Comparison · API Reference · Philosophy · 中文

"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 →)

Contents

Install

curl -fsSL https://openprogram.io/install | sh

macOS desktop: download the unsigned DMG from GitHub Releases. Linux uses the same CLI/server runtime and the Web UI; no Linux desktop package is published. Windows native packaging is not in this release.

Platform matrix, PATH, openprogram doctor, and source-checkout install: Installation.

Quick start

The first openprogram run opens a provider setup wizard, then the terminal chat. Re-run the wizard with openprogram setup.

openprogram

Open the Web UI at http://localhost:18100:

openprogram web

Confirm with one printed reply:

openprogram --print "Introduce yourself in one sentence"

GUI Agent, Research Agent, and Wiki Agent ship with every supported release. Third-party Programs use openprogram programs install <owner>/<repo>. Details: Getting Started.

News

  • 2026-08-17 — Built-in browser: multiple panes, bookmarks, History, and Agent control of visible pages.
  • 2026-07-21 — Multi-agent: spawn sub-agents, message across sessions, file-touching branches in git worktrees.
  • 2026-06-22 — 📄 Paper accepted at the KDD 2026 Workshop on Agentic Software Engineering (arXiv:2606.15874).
  • 2026-06-07 — Installable harnesses and multi-account providers with automatic key rotation.
  • 2026-05-28 — The Web UI design system.
  • 2026-04-04 — Built-in Anthropic / OpenAI / Gemini providers.
  • 2026-04-03 — 🌱 First release: @agentic_function and the execution DAG.

Why OpenProgram?

The current OpenProgram release supports macOS and Linux installations, multiple providers, and a Web interface (desktop App or openprogram web → http://localhost:18100). Windows native packaging is deferred for a later release decision; Windows and mobile devices can currently use the browser client against a supported remote host. The harness itself provides three mechanisms for building agent programs.

1. DAG Context — for native multi-agent systems

DAG Context — every user, LLM, and function call is one node on a single flat DAG; each @agentic_function declares in one line what context it reads and exposes, so fork, spawn, cross-session messaging, and worktree isolation all follow

Every user turn, LLM call, and function call is one node on a single flat DAG. Two edges give it meaning: caller (who invoked whom) and reads (whose output fed this prompt) — so context is assembled from the graph, not hand-stitched. Each @agentic_function is programmable context in one line: expose controls what a call reveals to its parent, and render_range controls how much history a call pulls in ({"callers": 0} gives a throwaway, self-isolated scratch context that's reclaimed when it returns — no unbounded prompt growth).

Because context is an addressable node rather than a per-agent buffer, multi-agent stops being a bolt-on: fork a branch, spawn a clean sub-agent, send_message across sessions, or run a file-touching branch in an isolated git worktree — each is just "select a different node set as context" on the same DAG.

2. Agentic Workflow — for trustworthy & self-evolving agents

Agentic Workflow — Python drives the flow and code gates enforce the critical steps; a failed validation makes the model re-decide so it cannot skip checks; the agent writes and hot-loads its own @agentic_functions

Python drives the flow; the LLM reasons only when asked. Critical steps become code gates — the model's choice is parsed and validated by code, and a failed check makes it re-decide instead of quietly moving on, so validation can't be skipped. Every call is a retryable, observable DAG node. That's what makes execution trustworthy: the guarantees live in code, not in the model's goodwill.

Self-evolving is a mechanism, not a black box: the agent writes and fixes its own @agentic_functions with ordinary file-edit tools, a file watcher hot-loads them, and the new tool is live on the next turn — no dedicated create() / fix() machinery.

3. Event Infrastructure — for proactive agents

Event Infrastructure — a unified process-wide event bus that the agent loop, auth, context, channels, and memory all emit onto; anything can subscribe by event type, and a proactive policy layer builds on top

One process-wide event bus is the substrate under everything: the agent loop, auth, context, channels, and memory all emit onto it, and any component can subscribe by event type (every event is a uniform Event(type, payload, ts) envelope with id / origin / metadata). This is deliberately a foundation — a proactive policy layer that watches the stream and acts is the bus's first intended consumer. The plumbing is in place; the proactivity is yours to build on it.

Citation

Using OpenProgram in your work, or building on the code? Please cite our paper — and under the AGPL, any derivative you distribute or run as a network service must itself be open-sourced under the AGPL, with attribution preserved (see License).

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

@inproceedings{qi2026llmascode,
  title     = {LLM-as-Code: Agentic Programming for Agent Harness},
  author    = {Qi, Junjia and Fu, Zichuan and Gao, Jingtong and Zhang, Wenlin and Yan, Hanyu and Wu, Xian and Zhao, Xiangyu},
  booktitle = {KDD 2026 Workshop on Agentic Software Engineering (AgenticSE)},
  year      = {2026},
  eprint    = {2606.15874},
  archivePrefix = {arXiv},
  url       = {https://arxiv.org/abs/2606.15874},
}

License

AGPL-3.0 © 2026 Fzkuji. Free to use, study, modify, and share — but any derivative you distribute or run as a network service must also be released under the AGPL, with attribution preserved.