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: none for the one-line install below (it provisions Python and, optionally, Node.js). For a manual install: Python 3.10–3.13, Node.js 18+ for browser UIs, and an LLM backend (Ollama, LM Studio, vLLM, or a cloud API key).

Quick start

One line installs the gateway (no admin rights, no system Python), registers it as a login service, starts it on 127.0.0.1:8080, and opens its web console already signed in. A first-run guide then sets up a local engine (Ollama, LM Studio, MLX, llama.cpp), downloads a model that fits your machine, and lists the apps:

# macOS / Linux
curl -LsSf https://raw.githubusercontent.com/lpalbou/AbstractFramework/main/scripts/install.sh | sh

# Windows 10 22H2+ / 11
powershell -ExecutionPolicy ByPass -c "irm https://raw.githubusercontent.com/lpalbou/AbstractFramework/main/scripts/install.ps1 | iex"

Add --with-apps, --with-ollama or --with-lmstudio for Node.js and local engines, --print to see every command first, and --uninstall to remove it. Options, the equivalent commands and uninstall details: Install.

Already have Python? Either entry point works the same way: start it, then open the link it prints.

pip install abstractcore && abstractcore serve        # http://127.0.0.1:8000/console#claim=…
pip install abstractgateway && abstractgateway serve  # http://127.0.0.1:8080/console#claim=…

Both consoles have Models (browse models that fit this machine, download, delete) and Engines (detect and install local engines) tabs; every action also shows its command-line equivalent (abstractcore models …, abstractcore engines …, abstractgateway models …).

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 serve starts the /v1 server on 127.0.0.1:8000 and prints a one-time link to its web console (Overview, Models, Engines, Providers). The same Models and Engines screens are available from the command line (abstractcore models catalog|list|download|delete, abstractcore engines status|install) and in the terminal console (cargo install abstractcore-console).

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
abstractgateway serve

With no auth configured, abstractgateway serve binds 127.0.0.1:8080, enables user auth, creates default/admin in the per-user data folder, and prints a one-time sign-in link (http://127.0.0.1:8080/console#claim=…, valid 10 minutes, this machine only). Open it to reach the web console and its first-run guide. abstractgateway claim mints a new link; abstractgateway service install starts the gateway at login.

To choose the data folder, the allowed browser origins or your own workflow bundles, set the environment explicitly:

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"
# export ABSTRACTGATEWAY_FLOWS_DIR="$PWD/bundles"   # serve your own bundle registry

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.

The admin user token is kept in <data dir>/auth/bootstrap-admin-token; use it to sign in to AbstractFlow, AbstractCode Web or AbstractObserver, or to the console without a claim link. 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.3.0 and ghcr.io/lpalbou/abstractcore-server:2.14.0.

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.2.0)

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
./scripts/deps.sh            # dependency tiers: what builds and installs first, and why
source ./scripts/build.sh    # Python (editable, into .venv), npm and Rust builds, tier by tier

Keep the whole workspace in sync with ./scripts/status.sh (git overview per tier; --registry compares local versions with PyPI, npm and crates.io), ./scripts/pull.sh, ./scripts/commit.sh and ./scripts/push.sh (a dry run until you add --yes). See docs/workspace-scripts.md for every script and option.

Then configure providers and models in a console (abstractcore serve or abstractgateway serve, then open the printed link), or from the terminal:

abstractcore --config    # interactive configuration wizard
abstractcore --install   # check every subsystem and download missing models and dependencies

License

MIT. See LICENSE.