What Is OpenAGI? A Self-Hosted Personal Agent Guide (2026)

OpenAGI is a personal agent that runs on a computer you control. It keeps context across sessions, learns routines from the activity you choose to share, supervises coding agents such as Codex and Claude Code from one view, and connects to the models, tools and devices you pick. This guide explains what OpenAGI is, how it differs from a chat assistant, and how to run the same workflow by hand before you install anything. It also covers installation, the Supervisor, privacy boundaries and current limits. If you run several AI coding agents and repeat the same morning checks across Slack, GitHub and your calendar, this guide is written for you.

What Is OpenAGI? (Definition)

OpenAGI is a persistent, self-hosted agent runtime built by Spencer Shulem, published at openagi.sh with source code at github.com/spshulem/openAGI. It runs as a long-lived process on your Mac, Linux box, Docker host or Raspberry Pi. You reach it through a local browser dashboard.

A note on the name: a 2023 academic project, OpenAGI: When LLM Meets Domain Experts (Ge et al., Rutgers), uses the same name and has no connection to this project. Other companies have used the name too. This guide covers only the personal agent at openagi.sh.

License. OpenAGI is source-available under the PolyForm Noncommercial License 1.0.0 (PolyForm NC). It is not an OSI-approved open-source license, because forbidding commercial use fails the Open Source Definition's rule against discriminating by field of endeavor. In practice, you can read, run and modify the code for personal, research, hobby, educational and other noncommercial purposes. Commercial use needs separate permission.

How it differs from a chatbot. A chatbot answers a message and forgets the context when the session ends. OpenAGI keeps running after you close the chat. It holds memory across sessions, stores saved routines, maintains connections to your accounts, and runs a Supervisor that keeps watching your coding agents while you do something else.

Who it is for. Engineers and technical leads who run several coding agents in parallel, repeat the same daily checks, or want agent state on their own hardware.

These are capabilities you configure and verify. Installing OpenAGI does not mean it will autonomously finish your work.

Chatbot vs. Persistent Personal Agent: What Actually Changes

The core change is that a persistent agent keeps state and keeps running, while a chat assistant resets with each conversation. The table below compares the two categories in general terms.

Four features make the difference in practice:

• Persistent runtime: the agent runs on your host and is reachable at http://127.0.0.1:43210/. Because 127.0.0.1 is the loopback address, the dashboard is reachable only from that machine by default.
• Memory: a chat continues tomorrow where it stopped today.
• Routines: it notices repeated activity you have shared and offers to save it as a skill. The skill runs only after you approve it.
• Supervisor: one view across coding agent sessions replaces tab-hopping between terminals and pull requests.

What Breaks Without a Persistent Agent

Without persistent state and supervision, AI-assisted work fails in predictable, repeatable ways. Running AI coding tools is now mainstream: the Stack Overflow Developer Survey 2025 reports that about 84% of respondents use or plan to use AI tools in development. That makes the following failure modes common.

• Context loss. Every new chat starts cold. You re-paste the repo layout, team conventions and yesterday's decisions, often several times a day.
• False "done." A coding agent reports a task complete while CI is red, checks are still pending, or the PR was never opened. Nobody notices until review.
• Silent blocking. An agent waits for input in a terminal you are not looking at. An hour of wall-clock time disappears with zero progress.
• Routine drift. The morning sequence of scanning the incident channel, checking yesterday's deploys and writing the standup gets done inconsistently, or skipped on busy days.
• Scattered state. Notes, prompts and agent transcripts live in five apps. There is no single record of what is in flight.
• Unbounded spend and unreviewed writes. Agents run with API keys and no per-turn or daily limits, or tools send email without a human check.

The same survey found that more developers distrust the accuracy of AI output (about 46%) than trust it (about 33%). That distrust is reasonable. The fix is a process that checks evidence, which you can run without any tooling.

The Method: Run a Personal Agent Workflow Manually (No Tool Required)

You can run a personal-agent workflow today with a text file and a terminal. The method works whether or not you ever install OpenAGI, and it makes any tool you adopt later easier to evaluate.

Step 1: Keep a context file

Maintain one markdown file per project with goals, conventions, open decisions and links. Paste it at the start of every AI session and update it at the end.

Step 2: Log your routines for one week

Write down every recurring check: the time, the source (Slack channel, GitHub, calendar) and the output (a note, a message). Anything that shows up three or more days in a week is a routine candidate.

Step 3: Turn routines into written runbooks

List inputs, steps and the expected output for each routine. Mark every step as read or write (send, post, merge, create event). Reads can be automated freely. Writes create external side effects and need a gate.

Step 4: Build a coding-agent status board

One row per agent session, with columns for agent, task, state (working / waiting on checks / blocked / waiting for you), thread link and PR link.

Step 5: Define "done" as evidence, not a claim

A task is done only when you can point to passing checks, a diff you have read, and an opened PR. Never accept the agent's summary alone. Apply the same rule to human contributors.

Step 6: Set a supervision cadence and modes

Decide per session whether you only observe, propose a nudge yourself, or allow a scripted retry within strict bounds.

Step 7: Gate every write

Email, calendar, messages and merges require explicit human approval. Write the approval rule into each runbook.

Step 8: Cap model spend

Set a daily budget and a per-task ceiling with your provider, and check usage weekly.

Checklist:

• ☐ Context file per project, updated every session
• ☐ One week of routine logging
• ☐ Runbooks with read/write labels
• ☐ Status board with four states and links
• ☐ Done = checks + read diff + open PR
• ☐ Mode chosen per session
• ☐ Approval rule on every write
• ☐ Daily and per-task spend caps

Worked Example: One Tech Lead's Monday Morning

A tech lead with four overnight agent sessions and a 9:30 standup can clear the morning in one structured pass instead of a scattered hour. The four sessions: two refactors, one test-coverage task and one dependency bump.

Routine pass. Following the written runbook, the lead checks #incidents in Slack (one open thread, already resolved), pulls yesterday's deploys from GitHub (three merged PRs), and drafts the standup from those two inputs. All three steps are reads. Posting the standup is a write, so it waits for a final look.

Status board pass.

• Session A says "done," but checks are still running. State: waiting on checks.
• Session B is blocked on a missing environment variable. State: waiting for you.
• Session C has passing checks and an open PR. State: genuinely done.
• Session D failed a lint step. State: blocked, with a proposed nudge.

Decisions. Answer B's question. Re-check A in 20 minutes. Read C's diff before approving. Send D a bounded instruction: "fix lint only, no other changes."

The time math. Each session costs a few minutes just to re-orient: find the terminal, scroll back, find the PR, check CI. Four sessions multiply that cost, and interruption research by Gloria Mark at UC Irvine suggests returning to an interrupted task can take far longer than the interruption itself. A single board with evidence links turns four investigations into four glances, because the state and the proof sit in the same row.

Where OpenAGI fits. Each manual step maps to a feature. The routine becomes a saved skill. The board becomes the Supervisor. "Done as evidence" becomes the Supervisor reading verification evidence instead of trusting the agent's message.

Common Mistakes When Adopting a Personal Agent

Most adoption problems come from granting trust before it has been earned. Watch for these mistakes:

• Assuming local storage means local inference. State lives on your host, but prompts go to whichever model provider you configured.
• Turning on autonomous modes before observing. Start in Observe, move to Propose once suggestions are reliably right, and enable Auto only for narrow, reversible actions.
• Sharing all activity at once. Share only the sources a specific routine needs, and widen later.
• Approving skills without reading them. A skill is effectively a script that acts with your credentials. Review it like code.
• Skipping spend limits because "it's just me." Long agent loops burn tokens fast. Set daily and per-turn caps on day one.
• Treating the agent as a teammate that finishes work. It surfaces state and proposes actions. You still own merges and sends.
• Piping an install script blindly. Before running curl -fsSL openagi.sh | sh on a machine that holds credentials, download the script and read it.

When You Need Tooling (and When You Don't)

Stay manual if you run one coding agent at a time, have fewer than two or three recurring daily checks, and rarely lose context between sessions. A context file and a short runbook cover that load with almost no overhead.

Consider tooling when any of these become true:

• You regularly run three or more parallel agent sessions.
• You keep missing "waiting for you" states and find stalled agents hours later.
• You re-paste the same context several times a day.
• Your routines span Slack, GitHub, calendar and email, and you want them run consistently with approval gates.

Whatever tool you evaluate, check for six properties:

1. Self-hosted state you can inspect and back up
2. Model choice, including local options
3. Approval required on writes
4. Daily and per-turn spend limits
5. Evidence-based status, not agent self-reports
6. Skills you can read before approving

The method above remains the core. The sections below describe how OpenAGI implements it.

OpenAGI: How to Install It

OpenAGI installs on macOS, Linux, Docker and Raspberry Pi, and runs from source on Windows.

After install, open the dashboard at http://127.0.0.1:43210/.

Choosing a host. A laptop agent sleeps when the laptop does, so overnight supervision stops when you close the lid. A Raspberry Pi 5 typically idles around 2.5 to 3.5 W, which makes it a cheap always-on home for the daemon. A home server works the same way.

Your First Five Minutes With OpenAGI

Spend the first five minutes setting limits and verifying behavior, not automating.

1. Connect a model. Choose a cloud API key, ChatGPT sign-in, a local model server, or Apple Intelligence on compatible devices.
2. Set spend limits. Configure daily and per-turn caps before anything else.
3. Test persistence. Start a chat, close the dashboard, reopen it and ask a follow-up. The agent should answer with the earlier context intact.
4. Connect one source. Google Calendar is a good first choice. Ask for an event and confirm the write prompts for approval.
5. Find your state. Confirm that ~/.openagi exists on the host and add it to your backups.
6. Leave the Supervisor in Observe. Watch how it classifies your sessions for a full day before changing modes.

The Supervisor: One View for Your Coding Agents

The OpenAGI Supervisor gives one view across Codex, Claude Code, Conductor and Antigravity sessions, and reports each session's real state with links to the work behind it.

• States: working, waiting on checks, blocked, or waiting for you. Each item shows the thread and the PR.
• Evidence over claims: it reads verification evidence, such as check results, instead of trusting an agent's "done."
• Modes: Observe watches only. Propose suggests nudges for you to send. Auto sends bounded nudges, and only after you explicitly enable it.
• Voice (optional): available on Mac, Android and Even G2 glasses. Every action requires a readback and a spoken approval code.
• Repair worker: if configured, it can open a bounded repair PR. You review and merge it yourself.

This is Steps 4 through 6 of the manual method, automated. The status board becomes the Supervisor view. The "done as evidence" rule becomes the evidence check. The per-session mode choice becomes Observe, Propose or Auto. Session A from the Monday example would show as waiting on checks automatically, and Session B would surface as waiting for you instead of sitting unseen in a terminal.

Routines, Skills and Connections

OpenAGI learns routines from the activity you choose to share and offers to save them as skills that run only after your approval. If it sees a weekday pattern (check #incidents in Slack, pull yesterday's deploys from GitHub, draft a standup), it proposes that sequence as a skill. You read the steps, approve or edit them, and the skill becomes repeatable. Learning uses only the sources you opt into, and the project describes optional local screen capture as one such opt-in source.

Connections include Gmail, Google Calendar, approved messaging contacts, MCP tools and reviewed skills. Email and calendar writes always require approval.

The Model Context Protocol (MCP) is an open standard that lets an agent call external tools and data sources through a common interface. An MCP server exposes capabilities, and the agent discovers and uses them. As one example, the buildbetter-mcp server can pull customer context into OpenAGI before a meeting. Any MCP server follows the same pattern, so you can connect only the tools a routine needs.

Privacy: Where Your Data Actually Lives

OpenAGI stores agent state in ~/.openagi on the host you control, but prompts still go to whichever model provider you configure. That distinction is the most important privacy fact about any self-hosted agent.

• Local state: memory, routines, skills and configuration live on your machine by default.
• Remote inference: with a cloud API key or ChatGPT sign-in, the prompts and context you send fall under that provider's data terms.
• Most local setup: point OpenAGI at a local model server, or Apple Intelligence on compatible devices. Expect weaker reasoning on long or complex tasks compared with large hosted models.
• Side-effect limits: approval gates on email and calendar writes, and spoken approval codes for voice actions, reduce unintended actions.

Operational advice:

• Back up ~/.openagi on a schedule.
• Restrict who can log in to the host. Anyone with shell access can read agent state.
• Apply least privilege: scope OAuth access and tokens to what each routine needs, and widen only when a new routine requires it.

What OpenAGI Does Not Do Yet

OpenAGI is early software with clear limits, and knowing them up front prevents bad surprises.

• No public mobile apps. Mobile apps are source/QA builds, with no app store release.
• No packaged Windows installer. Windows runs from source with Node.js 22+.
• No out-of-the-box autonomy. Capabilities need configuration and verification before they are useful.
• Auto mode is bounded and opt-in. It does not replace human review of merges or sends.
• Noncommercial license. PolyForm NC restricts commercial use. Read the terms before using it at work for a for-profit company.

Cloud Assistants vs. Self-Hosted Agents: Choosing a Category

Cloud assistants trade control for convenience, and self-hosted agents trade convenience for control.

Pick a cloud assistant if setup time matters most and you accept vendor-held state. Pick a self-hosted agent like OpenAGI if you want to own the host, the state and the model choice, and you are comfortable running updates.

FAQ

What is OpenAGI?

OpenAGI is a self-hosted personal agent by Spencer Shulem that runs on a computer you control. It keeps memory across sessions, learns routines from activity you choose to share, supervises coding agents such as Codex and Claude Code from one view, and connects to the models and tools you pick.

Is OpenAGI open source?

Not by the OSI definition. It is source-available under the PolyForm Noncommercial License 1.0.0. You can read, run and modify the code for noncommercial purposes, but commercial use is restricted by the license terms.

Is OpenAGI related to the OpenAGI research paper?

No. The 2023 academic project OpenAGI: When LLM Meets Domain Experts is a separate research platform. The personal agent covered here lives at openagi.sh and github.com/spshulem/openAGI.

Does OpenAGI keep my data on my computer?

Its state is stored in ~/.openagi on your host by default. Prompts may still go to the model provider you configure and fall under that provider's data terms. For the most local setup, use a local model server or Apple Intelligence on compatible devices.

Which coding agents can the OpenAGI Supervisor monitor?

Codex, Claude Code, Conductor and Antigravity sessions. It shows whether each is working, waiting on checks, blocked or waiting for you, with the linked thread and PR.

Can OpenAGI take actions without my approval?

Email and calendar writes require approval. The Supervisor's Auto mode only sends bounded nudges after you explicitly enable it, and voice actions need a readback and a spoken approval code.

How do I install OpenAGI?

Use the Mac DMG menu bar app, curl -fsSL openagi.sh | sh, Docker, or Linux/Raspberry Pi. On Windows, build from source with Node.js 22+. Then open http://127.0.0.1:43210/.

Is there an OpenAGI mobile app?

Not in public app stores. Mobile apps are currently source/QA builds.

Sources and Further Reading

• OpenAGI official site: https://openagi.sh
• OpenAGI README on GitHub: https://github.com/spshulem/openAGI
• PolyForm Noncommercial License 1.0.0: https://polyformproject.org/licenses/noncommercial/1.0.0
• Model Context Protocol documentation: https://modelcontextprotocol.io
• Software agent (Wikipedia): https://en.wikipedia.org/wiki/Software_agent
• Node.js downloads (for Windows source builds): https://nodejs.org
• Stack Overflow Developer Survey 2025 (AI tool adoption and trust figures)
• Gloria Mark, Attention Span (2023), on interruption and task resumption

Install OpenAGI in 5 Minutes

OpenAGI gives you persistent memory, approved routines and one Supervisor view across your coding agents, with state on hardware you control. Start in Observe mode, set your spend caps, connect one source, and widen access only as it earns trust.

Install OpenAGI in 5 minutes. Read the README, inspect the install script, and Star on GitHub.