AbstractFramework

Build durable, observable AI systems — fully open source, works offline.

AbstractFramework is a modular ecosystem for building AI agents and workflows that survive restarts, scale to production, and give you full visibility into what's happening. Every component is open source, works with local models, and designed to be composed however you need.

┌──────────────────────────────────────────┬──────────────────────────────────┐
│   GATEWAY PATH (Recommended)             │   LOCAL PATH (Alternative)       │
├──────────────────────────────────────────┼──────────────────────────────────┤
│                                          │                                  │
│  Browser UIs (Observer, Flow Editor,     │  AbstractCode (terminal)         │
│  Code Web, Your App)                     │  AbstractAssistant (macOS tray)  │
│              │                           │             │                    │
│              ▼                           │             │                    │
│  ┌────────────────────────────────────┐  │             │                    │
│  │        AbstractGateway             │  │             │                    │
│  │  ────────────────────────────────  │  │             │                    │
│  │  Bundle discovery (specialized     │  │             │                    │
│  │  agents across all clients)        │  │             │                    │
│  │  Run control (start/pause/resume)  │  │             │                    │
│  │  Ledger streaming (real-time SSE)  │  │             │                    │
│  └──────────────────┬─────────────────┘  │             │                    │
│                     │                    │             │                    │
└─────────────────────┼────────────────────┴─────────────┼────────────────────┘
                      └──────────────────┬───────────────┘
                                         ▼
┌─────────────────────────────────────────────────────────────────────────────┐
│  Composition: AbstractAgent (ReAct/CodeAct/MemAct) + AbstractFlow (.flow)   │
└─────────────────────────────────────────────────────────────────────────────┘
                                         │
                                         ▼
┌──────────────────────────────────────────────────────────────────────----───────┐
│  Foundation: AbstractRuntime + AbstractCore (+ Voice/Vision capability plugins) │
└──────────────────────────────────────────────────────────────────────────----───┘
                                         │
                                         ▼
┌─────────────────────────────────────────────────────────────────────────────┐
│  Memory & Knowledge: AbstractMemory · AbstractSemantics                     │
└─────────────────────────────────────────────────────────────────────────────┘

Why AbstractFramework?

• 100% Open Source — MIT licensed, no black boxes, you own everything
• Local First — Run entirely offline with Ollama, LM Studio, or any local model
• Durable — Workflows survive crashes; resume exactly where you left off
• Observable — Every operation is logged; replay any run from history
• Modular — Use one package or the full stack; compose what you need

Quick Start

Select a Provider / Model

Start a local model with Ollama

ollama serve && ollama pull qwen3:4b

or install lmstudio with the model you want

Alternatively use OpenAI / Anthropic / OpenRouter

Set one of those API keys as environment variable, OPENAI_API_KEY, ANTHROPIC_API_KEY, OPENROUTER_API_KEY

For the examples below, we will use ollama and qwen3:4b but you can use any provider:model.

Option 1: Terminal Agent (5 minutes)

The fastest way to try an AbstractFramework agent:

# Run AbstractCode
pip install abstractcode
abstractcode --provider ollama --model qwen3:4b

You now have a durable coding assistant in your terminal. Type /help to explore.

Durability: Your session persists across restarts — close and reopen, your full context is preserved. Start fresh with /clear.

Option 2: Tray Assistant (macOS)

Get a menu bar assistant with optional voice on macOS:

# Install and run
pip install abstractassistant
assistant tray

The assistant appears in your menu bar. Click to interact, or use keyboard shortcuts.

Durability: Sessions persist — your conversation history is preserved across app restarts.

Option 3: Just the LLM API

Use AbstractCore as a drop-in unified LLM client that work with any provider and model:

from abstractcore import create_llm

llm = create_llm("ollama", model="qwen3:4b-instruct")
# llm = create_llm("openai", model="gpt-4o")
# llm = create_llm("anthropic", model="claude-3-5-sonnet-latest")

response = llm.generate("Explain durable execution in 3 bullets.")
print(response.content)

Option 4: Gateway + Browser UI

Deploy a run gateway and observe workflows in your browser:

pip install "abstractgateway"

export ABSTRACTGATEWAY_AUTH_TOKEN="for-my-security-my-token-must-be-at-least-15-chars"
export ABSTRACTGATEWAY_DATA_DIR="my-folder/runtime/gateway"

abstractgateway serve --port 8080
npx @abstractframework/observer

Open http://localhost:3001, connect to the gateway, and start observing.

---

Install

Python Packages (pip)

Install only what you need:

# Foundation
pip install abstractcore                # Unified LLM API
pip install abstractruntime             # Durable execution

# Composition
pip install abstractagent               # Agent patterns (ReAct, CodeAct, MemAct)
pip install abstractflow                # Visual workflows

# Memory & Semantics
pip install abstractmemory              # Temporal triple store + vector search
pip install abstractsemantics           # Predicate/entity-type registry

# Applications
pip install abstractcode                # Terminal TUI (durable sessions)
pip install abstractassistant           # macOS tray app
pip install "abstractgateway"           # HTTP run gateway

# Modalities (optional capability plugins for AbstractCore)
pip install abstractvoice               # Adds llm.voice (TTS) + llm.audio (STT)
pip install abstractvision              # Adds llm.vision (image generation)

JavaScript/Node Packages (npm)

# Web UIs (run directly)
npx @abstractframework/observer        # Gateway observability dashboard
npx @abstractframework/flow            # Visual workflow editor
npx @abstractframework/code            # Browser coding assistant

# UI component libraries (for building your own apps)
npm install @abstractframework/ui-kit
npm install @abstractframework/panel-chat
npm install @abstractframework/monitor-flow
npm install @abstractframework/monitor-active-memory
npm install @abstractframework/monitor-gpu

---

The Ecosystem

Foundation

Package	What It Does	Install
AbstractCore	Unified LLM API — providers, tools, structured output, media	pip install abstractcore
AbstractRuntime	Durable execution — ledger, effects, pause/resume, replay	pip install abstractruntime

Composition

Package	What It Does	Install
AbstractAgent	Agent patterns — ReAct, CodeAct, MemAct loops	pip install abstractagent
AbstractFlow	Visual workflows — portable .flow bundles + editor	pip install abstractflow

Memory & Semantics

Package	What It Does	Install
AbstractMemory	Temporal triple store — provenance-aware, vector search	pip install abstractmemory
AbstractSemantics	Schema registry — predicates, entity types for KG	pip install abstractsemantics

Applications

Package	What It Does	Install
AbstractCode	Terminal TUI — durable coding assistant	pip install abstractcode
AbstractAssistant	macOS tray app — local agent with optional voice	pip install abstractassistant
AbstractGateway	HTTP server — remote runs, durable commands, SSE	pip install abstractgateway
AbstractObserver	Browser UI — observe, launch, and control runs	npx @abstractframework/observer

Modalities (AbstractCore Capability Plugins)

These are optional capability plugins for AbstractCore. Once installed, they expose additional capabilities on llm instances (e.g., llm.voice.tts(), llm.vision.t2i()), keeping AbstractCore lightweight by default.

Package	What It Does	Install
AbstractVoice	Voice I/O — adds llm.voice (TTS) and llm.audio (STT)	pip install abstractcore abstractvoice
AbstractVision	Image generation — adds llm.vision (text-to-image, image-to-image)	pip install abstractcore abstractvision

Web UIs (npm)

Package	What It Does	Install
@abstractframework/flow	Visual workflow editor (drag-and-drop)	npx @abstractframework/flow
@abstractframework/code	Browser-based coding assistant	npx @abstractframework/code

UI Components (npm)

Package	What It Does
@abstractframework/ui-kit	Theme tokens + UI primitives
@abstractframework/panel-chat	Chat thread + message cards + composer
@abstractframework/monitor-flow	Agent-cycle trace viewer
@abstractframework/monitor-active-memory	Knowledge graph explorer (ReactFlow)
@abstractframework/monitor-gpu	GPU utilization widget

---

Documentation

Guide	Description
Getting Started	Pick a path and run something
Architecture	How the pieces fit together
Configuration	Environment variables & providers
FAQ	Common questions

---

Philosophy

We built AbstractFramework because we wanted:

1. Full control — No vendor lock-in, no proprietary dependencies
2. Local by default — Privacy and cost control with open-source models
3. Durability — AI systems that don't lose work when things crash
4. Observability — Complete visibility, not a black box
5. Composability — Use what you need, replace what you don't

Cloud APIs are supported when you need them (complex reasoning tasks), but the framework is designed to run entirely on your hardware.

---

Contributing

Every package is its own repo. Find what interests you:

Foundation: AbstractCore · AbstractRuntime

Composition: AbstractAgent · AbstractFlow

Memory: AbstractMemory · AbstractSemantics

Apps: AbstractCode · AbstractAssistant · AbstractGateway · AbstractObserver

Modalities: AbstractVoice · AbstractVision

UI Components: AbstractUIC

---

License

MIT — see LICENSE.