OpenProgram
A self-programming AI assistant framework: Python fixes the flow, the LLM handles the judgement — capture, automate, and refine all your workflows.
Token handling shows rigor (backendAuth.test.ts asserts tokens never reach external URLs and cross-origin redirects are refused), and dependencies carry version caps with rationale. However, the core agent execution, sandbox, tool-permission, and confirmation flow source is not in the sample; least privilege, user confirmation, external effects, and rollback are asserted rather than shown — deducted. Data-flow transparency rests on narrative only.
pyproject documents every dependency's import path, symptom when missing, and version-cap reason; CI uses locked installs, a 120s test timeout, and a ruff exception-handling gate — good self-consistency and dependency availability. Failure-message quality is only indirectly evidenced; no actual error output was reviewed.
Platform matrix (macOS/Linux/Windows x64/arm64), Python 3.11–3.13, extras, and fallback paths (Ink→Rich REPL, pty→token paste) show careful environment fit. Boundaries are honestly labelled ('Windows sandbox remains a separate level', 'policy layer is yours to build'). Trigger precision for automation scenarios lacks evidence — deducted.
Full AGPL-3.0 text in-repo earns a top license score. Docs structure is clean, install notes cover the platform matrix and `openprogram doctor`, examples are rich and limitations honest. No CHANGELOG file (only a releases link), and maintenance is single-named ('Fzkuji') with no governance or response commitment — deducted.
README's side-by-side example clearly shows @agentic_function's value versus the common prompt/JSON pattern, and structured-output retry supports output usability. But marginal value and cost/benefit are narrative claims only: no benchmarks or token-cost analysis visible, and 'self-programming' gains cannot be verified statically — deducted.
Paper citation, arXiv link, and CI badges make key claims traceable; the README explicitly separates what is built from what the user must build — good fact/inference separation. But corroborating material (the paper's content, third-party evaluation) is not in this sample, so confidence stays low.
- Install uses curl|sh from openprogram.io with an unverified publisher; audit the script before running.
- The agent can self-modify and hot-load its own code, control a browser, and drive the GUI, but the sandbox/permission/confirmation implementations were not visible in this sample — verify each before production use.
- macOS DMG is unsigned; there is no CHANGELOG, so version traceability depends on GitHub Releases.
- AGPL-3.0 imposes open-source obligations when run as a network service; assess compliance cost before enterprise integration.
- This is a static, low-confidence review with no execution; key security claims (sandbox, token isolation) require reproduction.
What does this agent do, and when should you use it?
OpenProgram is a Python 3.11+ runtime for a self-programming AI assistant built around the "Agentic Programming" idea: the model provides flexible judgement while code provides deterministic flow. It ships a CLI (the openprogram command) and a Web UI (default http://localhost:18100, plus a desktop app); the first run opens a provider setup wizard. Its core mechanisms are the @agentic_function decorator (an agent is a Python function whose docstring is the system prompt), a flat DAG context (every call is an addressable node, enabling spawn, fork, cross-branch messaging, and git worktree isolation), code gates that force the model to re-decide on failed validation, and a process-wide unified event bus. The project comes with three companion open-source projects: GUI Agent, Research Agent, and Scriptorium (Markdown-based agent memory with MCP access). Its paper was accepted at the KDD 2026 AgenticSE Workshop. Licensed under AGPL-3.0, which requires derivatives distributed or run as network services to be open-sourced as well.
After a one-line install (curl script or PowerShell), openprogram opens a terminal chat, openprogram web starts the Web UI, and openprogram setup re-runs the provider wizard (built-in Anthropic, OpenAI, and Gemini providers with multi-account automatic key rotation). Developers write agents with the @agentic_function decorator: the docstring is the system prompt, arguments are inputs, llm() calls the model (choices=[...] re-asks until the answer is valid), and everything else is plain Python. For multi-agent work, spawn_branch() runs a sub-agent on clean context, message_branch() sends messages across branches, forking a node tries an alternative safely, and file-touching branches run in their own git worktree. A code gate bounces the model back to re-decide when validation fails. The agent can also edit its own @agentic_function files with ordinary file tools; a watcher hot-loads them so the new tool is live on the next turn. The event bus wraps agent loop, auth, context, channels, and memory output in a uniform Event(type, payload, ts) envelope, subscribable via get_event_bus().subscribe() by event type. Additional harnesses install via openprogram programs install <owner>/<repo>.
- Python developers building multi-agent systems who want sub-agent context isolation and cross-branch messaging without building messaging plumbing themselves
- Support/ticket teams building classify-and-reply pipelines where choices constraints guarantee parseable LLM output and code gates prevent the model from skipping validation
- Researchers using the companion Research Agent Harness to automate literature review, experiments, and paper drafts
- Teams needing agent memory, using Scriptorium to persist facts as Markdown notes cited to source messages
- Teams wanting a self-evolving toolchain where the agent writes and hot-loads its own @agentic_functions with no manual registration
- Ops/automation engineers subscribing to events like file.changed or context.compaction_recommended on the event bus to trigger alerts
What are this agent's strengths and limitations?
- @agentic_function turns an agent into a plain Python function — docstring as prompt, choices as output constraints — eliminating hand-written JSON schemas and manual re-prompt parsing
- The flat DAG context makes spawn, fork, cross-branch messaging, and git worktree isolation one-line calls; multi-agent capability is native, not bolted on
- Code gates force the model to re-decide on failed validation, so critical steps cannot be talked past via prompting
- The agent edits its own function files and a watcher hot-loads them, delivering genuine self-programming without create()/fix() machinery
- Complete cross-platform coverage — macOS, Linux, native Windows x86_64/arm64 CLI/server plus Web UI — with three major providers built in
- The AGPL-3.0 license requires any derivative distributed or run as a network service to be open-sourced under AGPL — a significant constraint for closed-source commercial integration
- Requires Python 3.11+, and Windows sandbox execution remains a separate level, not yet at parity with other platforms
- The proactive policy layer on the event infrastructure is not yet implemented; the README explicitly says that part is yours to build
- The macOS desktop DMG is unsigned and may be blocked by Gatekeeper in enterprise environments
- As a young framework (first release April 2026), the ecosystem and third-party integration evidence are limited; migration costs need your own evaluation
How do you install or deploy this agent?
macOS / Linux: curl -fsSL https://openprogram.io/install | sh. Windows x86_64 or arm64 CLI/server: irm https://openprogram.io/install.ps1 | iex. Desktop: macOS uses the unsigned DMG from GitHub Releases; Windows uses a signed win-x64.exe or win-arm64.exe when attached to the Release (otherwise the complete CLI/server runtime with Web UI). Requires Python 3.11+. See docs/install/install.md for the platform matrix, PATH setup, openprogram doctor, and source-checkout install.
How do you use this agent?
The first openprogram run opens a provider setup wizard (configure Anthropic/OpenAI/Gemini keys), then drops into terminal chat; openprogram setup re-runs the wizard. openprogram web opens the Web UI at http://localhost:18100. Quick verification: openprogram --print "Introduce yourself in one sentence". Write agents with @agentic_function, e.g. def triage(ticket: str, runtime=None) -> str, put the system prompt in the docstring, and call llm(ticket, choices=["bug","feature","question"]) for constrained model output. Install extra harnesses with openprogram programs install <owner>/<repo>.
How does this agent compare with similar options?
The README contrasts OpenProgram's approach with "the common way": hand-written TRIAGE_PROMPT and TOOLS JSON schema, a client.chat call, plus manual .loads parsing and re-prompting — i.e., the typical OpenAI-style tool-calling client pattern. OpenProgram replaces that boilerplate with decorators and typed constraints.