Vepol

A self-improving local AI partner that grows with you while every step stays inspectable.

OpenClaw made always-on agents feel real in everyday channels. Hermes makes agent runtimes feel expandable and compounding. Vepol goes after the next problem: an AI partner that plans your day, runs routine work, studies your patterns, self-reflects on its strategy, and takes on more of your work over time while you stay in control. The local markdown knowledge field is the mechanism that makes that growth auditable across Claude Code, Codex, Antigravity/Gemini and future CLI agents.

Read Vepol on GitHub Join the waitlist

Local: Runs on your machine
Self-improving: Strategy and autonomy evolve in files
Source-available: Read, fork, run

Vepol cover — a self-improving local AI partner with auditable memory

// agent field

The product is autonomy that compounds

Vepol is more than a shared agent workspace. It is a controlled self-improvement loop: observe the work, update the knowledge base, revise strategy, and raise autonomy only where the human has evidence.

Studies the way you work

After sessions, Vepol extracts decisions, lessons, action items and patterns, then uses them in tomorrow’s plan.

Self-reflects in the open

Vepol writes a retro after each day, and strategy assumptions are revised in files you can inspect, edit or roll back.

Autonomy grows under control

Every task type starts supervised: Vepol drafts, you edit. Where your edits approach zero, that task type graduates to background execution — the daily routine already runs unattended, every action logged.

// inspectable proof

Self-improvement with a visible trail

The repository is explicit: Vepol plans, runs routine work, studies the user, self-reflects — and its autonomy is designed to compound. Every improvement passes through readable files, so each step can be audited.

Five pillars of Vepol's working discipline: durable memory, shared context, review gates, incident loop, human override — **Visible discipline**The system keeps durable memory, shared context, review gates, the incident loop and human override in one readable structure.

Category map for OpenClaw, Hermes and Vepol — presence, runtime and local knowledge field — **OpenClaw / Hermes / Vepol**OpenClaw is presence in channels. Hermes is runtime breadth. Vepol is the controlled self-improvement loop that keeps agency coherent.

Vepol autonomy growth timeline — context compounding from first day to later work — **Autonomy compounds**Vepol becomes more useful by preserving what was accepted, edited, blocked and learned, then adjusting its next plan.

// operating field

One field for people and agents

Vepol’s self-development is deliberately not hidden inside a model. Runtime can change; strategy, memory, incidents, reviews and autonomy rules stay in plain files.

Vepol architecture diagram — many agents working over one shared knowledge field — Human judgment, CLI agents, plans, incidents, strategies and decisions operate over one local knowledge base that turns experience into safer autonomy.

// open development

Open development

Vepol is used to evolve Vepol: specs, tests, reviews, incidents, strategy updates and follow-up work go through the same knowledge base described on this page.

GitHub repositoryRead the source, docs and release trail.MethodologyHow shared memory, review gates and agent handoff are designed.Demo wikiA synthetic example showing how the knowledge base feels in use.

Licence: FSL-1.1-MIT Commercial use

Waitlist

Want an AI partner that improves with your work?

Leave a short note. We will route it to the lab and reply directly.