Self-Programming AI Assistant. Capture, automate, and refine all your workflows.

Getting Started · Install · Docs · 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
• Quick start
• Integrated Projects
• News
• Why OpenProgram?
  • 1. Agentic Function — the primitive everything else is built on
  • 2. DAG Context — for native multi-agent systems
  • 3. Agentic Workflow — for trustworthy & self-evolving agents
  • 4. Event Infrastructure — for proactive agents
• Also in the product
• Citation
• License
• Acknowledgements

Install

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

Windows x86_64 or arm64 CLI/server (requires a release with Windows runtime assets):

irm https://openprogram.io/install.ps1 | iex

If the selected release has no Windows runtime ZIP and checksum, use the Windows source-development installation.

Desktop: macOS releases use the signed and notarized DMG; Windows uses a signed win-x64.exe or win-arm64.exe when that artifact is attached to the GitHub Release. Linux and Windows without that EXE use the complete CLI/server runtime and Web UI.

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"

Details: Getting Started.

Integrated Projects

Our open-source projects cover desktop automation, research workflows, and agent memory. Visit their repositories for source code, documentation, and contributions.

Install more: openprogram programs install / (guide).

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?

OpenProgram supports macOS and Linux installations, native Windows x86_64/arm64 CLI/server, multiple providers, and a Web interface (Desktop App or openprogram web → http://localhost:18100). The Windows Desktop distribution path produces a signed per-user installer and embeds the same complete runtime; Windows sandbox execution remains a separate level. The harness itself provides four mechanisms — one primitive and the three capabilities it enables.

1. Agentic Function — the primitive everything else is built on

An agent is a Python function. You write it like any other function. The docstring is the system prompt: it tells the model what this agent does. Each argument is input for this run. A str argument is the task. In this example the task is the ticket to classify. You do not store the prompt or the JSON as separate variables. They are written as code. choices=[...] asks again until the answer is one of those words.

Here is an example, compared with the common way:

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

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

2. 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":

3. 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.

4. 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.compacted", "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.

Also in the product

The four mechanisms above are the thesis. Below are other designs that are not the usual shape — shipped items are checked.

• 🧠 Scriptorium. Markdown under ~/.openprogram/memory/, every paragraph cited, written in background batches — there is no "save this" tool. Details
• ♾️ Infinite Context. Occupancy drives /compact and automatic compact; tool results inside a single turn can compact without another command; original records stay in the session. Details
• 🌿 Conversation stored as git. History is a repo, not a list: branch, attach, and merge from the sidebar. Details
• 🎯 Goals in ordinary chat. Persistent goals with bound todo plans live in the same conversation, not a separate Goal mode.
• 👁️ Proactive policies. The event bus is live; a layer that watches it and acts on its own is the next piece of that design.
• 🖥️ Agent terminal. A host-owned PTY for the agent is underway — not yet a chat tool.
• 🔄 Self-update. The agent patching and replacing its own runtime in conversation — with owner approval, verification, and recovery — is still a goal. Details

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.

Acknowledgements

Thank you to everyone who helps improve OpenProgram through code, bug reports, reproductions, tests, documentation, reviews, and suggestions.

Thank you also to everyone who helps through issues and pull requests.