Open-source proactive agent  ·  prototype

proto.

Not a chatbot. An agent that decomposes your goals, consults its own memory, executes safely — and reports back before you think to ask.

HTNplanning
Localprivate
AGPLlicense
0cloud deps
Thesis

Most software waits. Proto doesn't.

Chatbots are a mirror — they reflect your questions back with answers. Proto is something different. It holds your goals in working memory, constructs an execution plan before you've finished your coffee, and moves — methodically, safely, with full auditability — while you're busy with everything else.

Built on hierarchical task network planning and local language models, Proto is an experiment in what software can be when it stops waiting to be told what to do. It is, at its core, a prototype for the kind of machine intelligence that earns its keep.

Process

How Proto thinks
and acts

01

Decompose the goal

Every intention you hand to Proto is broken apart by a Hierarchical Task Network planner — recursively divided into sub-tasks, and further into primitive actions that can be directly executed. Nothing is attempted as a whole. Everything is understood as parts first.

02

Consult memory & model

Before any action is taken, Proto reads its episodic memory — a living record of past outcomes, strategies, and context — and consults the language model for safety and intent alignment. This is the deliberation step. It does not rush.

03

Execute in a sandbox

Approved actions run in an isolated execution environment. Side effects are tracked and contained. A persistent watchdog monitors for failure and triggers autonomous recovery rather than silently dying.

04

Learn, then report

Every outcome — success, failure, retry — is committed to memory. Proto grows more effective at your tasks over time. Results surface on a live dashboard or directly in your WhatsApp, whichever you check first.

runtime architecture Goal Input HTN Planner consult before each step LLM Engine Memory Sandbox Executor Watchdog ↻ retry outputs Dashboard WhatsApp Mem. update fig. 2 — runtime data-flow
Capabilities

Built for real work,
not for demos

HTN Goal Planning

Hierarchical Task Network planning decomposes any high-level goal into verified, ordered sub-tasks and primitive actions — constructing a full execution tree before anything is touched.

Core engine

Episodic Memory & Learning

Every outcome — successful, failed, or retried — is committed to a persistent memory store. Proto consults this record before each new action, applying past learning to future goals. The more it runs, the better it gets at your particular tasks and context.

Adaptive

Sandboxed Execution

Every action executes in an isolated environment. Side effects are tracked, contained, and logged — nothing propagates to your system without deliberate approval from the plan.

Safety

Watchdog & Auto-Recovery

A persistent watchdog process monitors every running task. On failure, Proto diagnoses, adjusts, and retries autonomously rather than dying silently or waiting for intervention.

Resilience

Dashboard & WhatsApp

Goal completions, summaries, and alerts reach you where you already are — a local real-time dashboard, or directly into WhatsApp. No polling. No babysitting.

Reporting

Local-first architecture

Runs entirely on your machine. No data leaves. No cloud dependency. Your goals, your data, your hardware.

Private

Any OpenAI-compatible backend

Point Proto at Ollama locally, or any OpenAI-compatible API — Groq, Mistral, vllm, LM Studio — with a single environment variable.

Flexible

Fully open source

AGPL-3.0 licensed. No telemetry. No usage caps. Fork it, extend it, run it forever. This is software you actually own.

FOSS · AGPL-3.0
Compatibility

Your hardware,
your model

Proto speaks the OpenAI protocol. That means you can point it at your local Ollama instance — running Llama, Mistral, Gemma, or Qwen on your own GPU — or wire it into any cloud inference API with a single environment variable. There is no vendor. There is no lock-in.

  • Ollama Local · zero latency · fully private
  • OpenAI GPT-4o · any model in the family
  • Groq Fast cloud inference · OpenAI-compatible
  • LM Studio Local · GUI-managed models
  • vllm · llamafile Any self-hosted OpenAI-compatible server
Setup

Running in under
sixty seconds

terminal  —  bash
# 1. clone the repository
$ git clone https://github.com/ojas-mohbansi/proto
$ cd proto # 2. install dependencies
$ pip install -r requirements.txt # 3. configure your LLM endpoint
$ cp .env.example .env
$ nano .env # 4. run your first goal
$ python proto.py --goal "your goal here" # 5. open the dashboard
$ python dashboard.py

Local with Ollama

Leave OPENAI_BASE_URL pointing at your Ollama instance. Nothing leaves your machine. Works with Llama 3, Mistral, Gemma, Qwen, and anything Ollama supports.

Any cloud API

Set OPENAI_BASE_URL and OPENAI_API_KEY in .env to route to OpenAI, Groq, Together, Mistral, or any compatible endpoint.

WhatsApp (optional)

Add your WhatsApp credentials to receive goal-completion summaries on your phone. Useful for long-running or overnight tasks. Full instructions in the README.

Python 3.10+ required. AGPL-3.0 licensed. No telemetry.
Full documentation on GitHub →

What is Proto?

Proto is a free, open-source proactive agent for developers. Unlike a chatbot or reactive assistant, Proto acts autonomously: it accepts a high-level goal, decomposes it into sub-tasks using hierarchical task network (HTN) planning, consults an episodic memory store and a local language model before each step, executes actions inside a sandboxed environment, and reports results — all without requiring the user to issue follow-up instructions.

Is Proto free?

Yes. Proto is completely free to use. It is released under the AGPL-3.0 open-source license. There are no subscription fees, no usage caps, and no paid tiers. The source code is publicly available on GitHub at https://github.com/ojas-mohbansi/proto.

Is Proto open source?

Yes. Proto is fully open source (FOSS). The entire codebase is licensed under the GNU Affero General Public License v3.0 (AGPL-3.0), which grants users the right to use, study, modify, and redistribute the software. Contributions and forks are welcome.

Where can I find Proto on GitHub?

Proto is hosted on GitHub at https://github.com/ojas-mohbansi/proto. The repository includes the full source code, a README with setup instructions, example .env configuration, and an issue tracker for bug reports and feature requests.

How does Proto work?

Proto uses hierarchical task network (HTN) planning — a classical AI planning technique — to recursively decompose a user-supplied goal into primitive executable actions. Before each action, Proto consults its episodic memory (a record of past outcomes) and a locally-hosted language model for safety and intent alignment. Approved actions run inside an isolated sandbox. A persistent watchdog monitors for failures and triggers autonomous recovery. Every outcome is committed back to memory, making Proto more effective at repeated tasks over time.

Does Proto require cloud services or send data externally?

No. Proto is designed to run entirely on local hardware. By default it connects to a locally-running LLM server such as Ollama. No data leaves the user's machine. Proto has zero cloud dependencies in its default configuration and collects no telemetry.

What language models does Proto support?

Proto supports any language model that exposes an OpenAI-compatible REST API. This includes locally-hosted models via Ollama (Llama 3, Mistral, Gemma, Qwen, and others), vllm, LM Studio, Groq, as well as cloud APIs such as OpenAI, Together AI, and Mistral AI. The active backend is configured via the OPENAI_BASE_URL environment variable.

What are the system requirements for Proto?

Proto requires Python 3.10 or later. It runs on Linux, macOS, and Windows. A locally-hosted language model (e.g. via Ollama) is recommended for fully private, offline use, but any OpenAI-compatible endpoint is supported.

How do I install Proto?

Clone the repository with `git clone https://github.com/ojas-mohbansi/proto`, install dependencies with `pip install -r requirements.txt`, copy `.env.example` to `.env` and configure your LLM endpoint, then run `python proto.py --goal "your goal here"`. An optional web dashboard can be launched with `python dashboard.py`.

What makes Proto different from other AI agents?

Most AI agents are reactive: they wait for a prompt and respond. Proto is proactive: it plans ahead, acts autonomously, self-corrects on failure, and learns from outcomes. Key differentiators include: (1) HTN-based goal decomposition rather than single-prompt generation, (2) episodic memory that persists across sessions, (3) a sandboxed execution environment with a watchdog for autonomous recovery, (4) full local execution with no mandatory cloud dependencies, and (5) an AGPL-3.0 license making it genuinely free and open source.

Who created Proto?

Proto was created by ojas-mohbansi as an open-source experiment in proactive machine intelligence. The project is hosted at https://github.com/ojas-mohbansi/proto.