SELF-UPGRADING ENGINE · AGI SEED 11/11
Production-ready core · MIT · Python 3.10+

The AI engineering engine
that improves itself.

OWL CODE is not a chatbot that suggests snippets. It is a terminal agent with an explicit engineering loop — and a built-in self-improvement architecture designed to grow toward more capable autonomous software work.

See AGI roadmap Acquisition

Private repository. Access for verified buyers. 33 tools · 8 skills · multi-provider (incl. Ollama).

owl-code · project/
owl> ▋

An engine, not a single product.

OWL CODE is designed as a self-aware, self-modifying, self-improving software agent. The core value is the growth loop: inspect itself, propose improvements, apply changes under permissions, verify with tests, persist patterns and goals — then reuse that learning across projects.

AGI seed = Self-Awareness + Self-Modification + Self-Directed Growth + Learning from Experience + Cross-Project Knowledge + External Knowledge + Autonomous Improvement + Self-Evaluation + Planning & Sub-Goals + Generalization + Autonomy & Agency

Buying the engine means optionality. Run it as the backbone of an AI software company, offer agentic engineering as a service, or embed it via the Connector API. Pair it with cloud models or a full local stack (Ollama) and you own the runtime, the tools, and the improvement loop — not a rented chat session.

Independent AI product

Ship a branded engineering agent on top of OWL CODE’s loop, tools, and memory.

Agency / services

Deliver multi-project automation with shared learning and permissioned execution.

Local platform (Ollama)

Same agent loop against local models — a complete stack without a single cloud vendor lock-in.

Vision (not a present capability claim): with sufficient infrastructure (compute, models such as Ollama, and operational controls), the same self-improvement architecture is intended to scale toward stronger autonomous behavior. Today the product ships a completed AGI seed roadmap (11/11 phases as documented) — not a claim of human-level AGI or ASI.

33Tools
8Skills
11/11AGI phases
156+Tests
MITLicense
4Providers

The gap

Most AI coding tools stop at suggestions.

Real software work needs repository understanding, inspection, planning, controlled edits, test runs, verification, and a clear report — plus a path for the system to get better over time. OWL CODE is built around that loop and around self-improvement as a first-class capability.

Core architecture

The engineering loop

UNDERSTAND → INSPECT → PLAN → EXECUTE → TEST → VERIFY → REPORT. Bounded by max_iterations. Early stop if tests fail three times in a row. Permission-audited. Workspace path sandbox enforced.

01

Understand

Task & context

02

Inspect

Files, Git, stack

03

Plan

Concrete plan

04

Execute

Edits & commands

05

Test

Run suite

06

Verify

Outcomes

07

Report

Structured summary

AGI Self-Upgrading Roadmap

11 of 11 phases complete

Documented in AGI_ROADMAP.md. This is the growth tree the product was built around — from foundation engineering to autonomy & agency. Presented as an architecture milestone, not a claim that the system is already general intelligence.

Phase 1
Foundation — core loop, filesystem, terminal, git, permissions
100% ✓
Phase 2
Self-awareness — self_inspect, own architecture, skills
100% ✓
Phase 3
Self-modification — self_improve, own source under safety constraints
100% ✓
Phase 4
Self-directed growth — propose_improvement, improvements backlog
100% ✓
Phase 5
Learning & memory — reflective memory, 3 tiers, cross-project shared
100% ✓
Phase 6
External knowledge — web_search, web_fetch
100% ✓
Phase 7
Autonomous improvement loop — review, verify, apply, rollback
100% ✓
Phase 8
Self-evaluation — scoring, trends, goals from weak areas
100% ✓
Phase 9
Planning & sub-goals — create / track / view plan
100% ✓
Phase 10
Generalization — patterns, transfer learning, prompt injection
100% ✓
Phase 11
Autonomy & agency — goals, self_act, approval always on
100% ✓

Persistent artifacts: improvements.json, patterns.json, autonomy.json, evaluation.json. Autonomous actions require user approval by design.

Capability surface

33 tools, permissioned by design

Every call is checked against READ / WRITE / EXECUTE / SYSTEM. Filesystem tools refuse paths outside the workspace root.

Filesystem

  • read_file
  • write_file
  • edit_file
  • delete_file
  • list_directory
  • search_files

Terminal

  • execute_command
  • run_tests

Git

  • git_status
  • git_diff
  • git_log

Project

  • detect_project_type

Web

  • web_search
  • web_fetch

Self-Improvement

  • self_inspect
  • self_improve
  • propose_improvement
  • review_improvements
  • self_verify
  • run_improvement_loop
  • self_evaluate

Planning

  • create_plan
  • track_plan
  • view_plan

Generalization

  • store_pattern
  • generalize
  • view_patterns

Autonomy

  • set_goal
  • review_autonomy
  • self_act

Delegation

  • delegate_task
  • list_agents

System Admin

  • system_info
  • list_desktop
  • organize_folder
  • search_system

Datetime

  • datetime_util

Providers

Cloud models or full local stack

Same agent, different backends. Ollama for local models — no extra SDK beyond core requests. Configure via env, user config, or project config.

OWL CODE Loop · Tools · Permissions · Memory · Self-upgrade
AnthropicANTHROPIC_API_KEY
OpenAIOPENAI_API_KEY
DeepSeekDEEPSEEK_API_KEY
OllamaLocal · localhost:11434

Guidance & memory

8 skills · layered memory

Python

PEP 8, reproducibility, stdlib-first.

Git

Safe workflows; no force-push without request.

Debugging

Reproduce → isolate → fix → verify.

Delegation

Multi-agent task handoff.

Self-Improvement

Inspect, improve, propose, verify.

Server Management

Flask, FastAPI, Express.

System Admin

Ports, processes, folders.

Web Research

Search + fetch external knowledge.

Short-term

In-memory; cleared between sessions.

Project

<workspace>/.owl_code/project_memory.json

Long-term

User-level memory_file

Shared

Cross-project learning across workspaces.

Control

Self-improving ≠ uncontrolled

Autonomy tools still require approval. Destructive paths and shell patterns are SYSTEM-level. Workspace escape is blocked regardless of config.

READ

Inspect files, Git, search

Never prompted
WRITE

write_file, edit_file

Prompted
EXECUTE

execute_command, run_tests

Prompted
SYSTEM

delete, destructive shell

Prompted

Integration

CLI · Connector · Docker

CLI

cd /path/to/your/project
owl-code

owl-code --task "Fix the failing test" --workspace .

echo '{"task":"...","workspace":".","auto_approve":true}' | owl-code --task-json -

Connector API

Functional: run_task, run_task_subprocess, run_from_stdin, serve_http. Templates only (not production services): server.py, client.py, hub.py, delegate.py — see CONNECTOR.md.

Docker demo

docker compose up --build
# POST http://localhost:8765/task — demo remote submission, not hardened prod

Strategic

Acquire the engine

OWL CODE is available for acquisition. Private repository; access for verified buyers. You are not buying a thin wrapper around a single API — you are buying the loop, the tool registry, the permission model, the memory tiers, and the self-upgrade path.

  • Self-upgrading AGI seed architecture — 11/11 phases documented complete
  • 33 tools · 8 skills · multi-provider (Anthropic, OpenAI, DeepSeek, Ollama)
  • Engineering loop with permissions and workspace sandbox
  • Persistent self-improvement artifacts and cross-project learning
  • CLI + Connector surface for embedding in products and pipelines
  • 156+ tests · MIT license · Docker demo for connector HTTP
  • Positioning flexibility: product company, agency platform, or local Ollama stack
Request acquisition information

Replace contact with the owner’s preferred channel when publishing.

Own the loop. Own the upgrade path.

An engineering agent that can inspect, change, test, and improve — under your control.

Acquisition / access AGI roadmap

pip install owl-code · Python 3.10+