AbstractFramework

Write once. Generate everything.

A modular, open-source ecosystem for building durable, observable, multimodal AI systems. Text, voice, image, video, music — one unified interface, any provider, any model, local or cloud.

AbstractFramework is an ecosystem of composable packages for building AI systems that work in operational reality:

• Durable by default: workflows pause and resume safely (survive crashes and restarts)
• Observable: an append-only ledger so any UI can reconstruct state by replaying history
• Controlled actions: explicit boundaries for tool execution, approvals, and evidence
• Multimodal: capability plugins (voice, vision, music) that stay out of your way until you need them

Think of it as an agentic OS: durable runs + replay-first observability + multimodal capabilities — write once, run across providers and deployment modes.

Prerequisites: Python 3.10+. Node.js 18+ for browser UIs. An LLM backend (Ollama, LM Studio, vLLM, or a cloud API key).

Two entrypoints

Start lightweight with just the LLM library, or go all-in with a production gateway. Both paths lead to the same ecosystem.

1) AbstractCore — LLM SDK + OpenAI-compatible /v1 server

Start here if you need a lightweight LLM library for scripts, notebooks, or existing applications. No infrastructure required — just pip install and call. Add multimodal capabilities with plugins as you grow.

• 9+ providers with identical API (local + cloud)
• Universal tool calling, structured output, streaming
• Media handling (images, PDFs, audio, video)
• OpenAI-compatible HTTP server mode (/v1)
• Multimodal via capability plugins (Voice, Vision, Music)

pip install abstractcore

from abstractcore import create_llm

llm = create_llm("ollama", model="qwen3:4b-instruct")
resp = llm.generate("Explain durable execution in 3 bullets.")
print(resp.content)

AbstractCore gives you one interface for provider switching, tools, structured output, and media — as a Python SDK or via /v1 for any OpenAI-compatible client.

2) AbstractGateway — durable run control plane (HTTP/SSE APIs)

Start here if you're building persistent AI applications — agents that run for hours, workflows that survive crashes, scheduled tasks. The gateway is your AI control plane: durable runs with ledger replay/streaming and thin clients that can attach/detach across devices.

• Durable execution that survives crashes and restarts
• Append-only ledger (replay-first) for auditability
• Scheduled workflows (cron-style, recurring)
• Multi-client: terminal, browser, tray, Telegram, email
• Start on one device, continue on another

pip install abstractgateway

export ABSTRACTGATEWAY_USER_AUTH=1
export ABSTRACTGATEWAY_ALLOWED_ORIGINS="http://localhost:*,http://127.0.0.1:*"
export ABSTRACTGATEWAY_WORKFLOW_SOURCE=bundle
export ABSTRACTGATEWAY_DATA_DIR="$PWD/runtime/gateway"

# Optional: set only to serve your own bundle registry instead of the
# workflows Gateway ships with.
# export ABSTRACTGATEWAY_FLOWS_DIR="$PWD/bundles"

abstractgateway serve --host 127.0.0.1 --port 8080

Out of the box this serves a ready set of workflows — a verify-gated coding agent, deep-research, and co-scientist among them. See shipped workflows.

On first local start, Gateway creates default/admin, writes the browser-login token to runtime/gateway/auth/bootstrap-admin-token, and prints the token in the terminal. Use that admin user token in the built-in web console at http://127.0.0.1:8080/console, AbstractFlow, AbstractCode Web, or AbstractObserver. ABSTRACTGATEWAY_AUTH_TOKEN remains a legacy server/operator bearer token; it is not a browser sign-in token.

Monitor runs from a browser, or from a terminal with the gateway console:

npx @abstractframework/observer   # open http://localhost:3001

cargo install abstractgateway-console   # Rust 1.87+
ABSTRACTGATEWAY_AUTH_TOKEN=<token> abstractgateway-console --url http://127.0.0.1:8080

Container images are published for the gateway and the AbstractCore server: ghcr.io/lpalbou/abstractgateway:0.2.30 (0.2.30-gpu is an experimental NVIDIA image) and ghcr.io/lpalbou/abstractcore:2.13.42.

For artifact and runtime-resource investigation, see docs/guide/runtime-artifacts.md.

Author once, run everywhere (AbstractFlow)

AbstractFlow lets you author complex agentic orchestration as portable .flow bundles:

1. Open the Flow Editor (npx @abstractframework/flow)
2. Build a workflow: LLM steps, tool steps, branching, loops, subflows
3. Export a .flow bundle into your own bundle directory and point ABSTRACTGATEWAY_FLOWS_DIR at it (or publish it through the Gateway API)
4. Run it from any gateway-backed client (Observer, AbstractAssistant, Code Web UI, your app)

AbstractAgent provides ready-made agent patterns (ReAct, CodeAct, MemAct) that can be used inside flows or standalone. The workflows Gateway ships with are authored the same way — their editable sources are documented in shipped workflow sources.

Monitor and schedule with AbstractObserver

• Observe: replay the full ledger of any run, or watch one live over SSE
• Control: cancel, resume, or inspect runs from the browser
• Schedule: durable schedules (cron-style) owned by the gateway — they survive restarts

Package map

The ecosystem, grouped by layer. Each name links to the package's own README.

Foundation

Durable execution

Control plane

Multimodal capabilities

Apps and clients

Shared libraries

Install the pinned ecosystem profile

Light / Apple / GPU profiles

Choose how the framework runs based on your hardware and constraints. All profiles keep the same interfaces; they mainly change which local inference stacks are available.

Light (default) — endpoint-only inference (cloud APIs or local OpenAI-compatible servers), no in-process ML engine stacks:

pip install abstractframework

Apple — native Apple Silicon local stacks (MLX/Metal) in addition to endpoint providers:

pip install "abstractframework[apple]"

GPU — native GPU local stacks (CUDA/ROCm) in addition to endpoint providers:

pip install "abstractframework[gpu]"

Release matrix (abstractframework 0.1.12)

abstractframework pins every Python package with ==, so one version of the meta-package always installs the same stack. The browser apps and Rust tools are distributed through npm and crates.io; the versions below are the ones released and tested together.

Optional add-ons that are not part of any profile install separately: pip install abstract3d (0.3.1), pip install abstractcamera (0.2.0) and pip install abstractskill (0.2.1).

See docs/install.md for the full install chooser, uv/venv guidance, abstractframework doctor, and the generated installer manifest contract.

Documentation

Developer setup (from source)

Clone all sibling repos and build everything in editable mode:

./scripts/clone.sh           # clone every sibling repository next to this one
source ./scripts/build.sh    # editable installs into .venv (use `source` to stay in the venv)

Then configure:

abstractcore --config
abstractcore --install

License

MIT. See LICENSE.