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).
The installer sets up the gateway in your user account (no admin password, no system Python),
asks whether to start it at login, starts it on 127.0.0.1:8080, and opens its web console in
your browser 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.
-
Mac, no Terminal: download and double-click AbstractFramework-Installer.pkg. The package is not signed with an Apple Developer ID, so the first time macOS blocks it: open System Settings > Privacy & Security, click Open Anyway next to the installer's name and confirm. A Terminal window then shows each step; press Return at its one question.
-
macOS / Linux, one line:
curl -LsSf https://raw.githubusercontent.com/lpalbou/AbstractFramework/main/scripts/install.sh | sh -s -- --interactive -
Windows 10 22H2+ / 11 (PowerShell):
powershell -ExecutionPolicy ByPass -c "irm https://raw.githubusercontent.com/lpalbou/AbstractFramework/main/scripts/install.ps1 | iex"
Every failure says what to do next; running the installer again repairs or upgrades in place. To
remove it, double-click Uninstall AbstractFramework.command (in
~/Library/Application Support/AbstractFramework/Installer after a package install), or run
curl -LsSf https://raw.githubusercontent.com/lpalbou/AbstractFramework/main/scripts/uninstall.sh | sh.
Step by step, the failure table, options (--with-apps, --with-ollama, --print, …):
Install. Something not working: Troubleshooting.
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 …).
Start lightweight with just the LLM library, or go all-in with a production gateway. Both paths lead to the same ecosystem.
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 abstractcorefrom 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.
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 serveWith 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.
Browser apps on http://localhost:* and http://127.0.0.1:* may always call it. To choose
another data folder or allow another browser origin:
abstractgateway serve --data-dir "$PWD/runtime/gateway"
abstractgateway network set --allowed-origins https://ui.example.comTo serve your own workflow bundles instead of the shipped ones, start the gateway with
ABSTRACTGATEWAY_FLOWS_DIR pointing at your bundle folder.
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:8080Container images are published for the gateway and the AbstractCore server:
ghcr.io/lpalbou/abstractgateway:0.5.1 and ghcr.io/lpalbou/abstractcore-server:2.16.1.
For artifact and runtime-resource investigation, see Runtime artifacts and retrieval.
Every client (AbstractCode in the terminal and the browser, AbstractAssistant, your own app) chats with agents through the same gateway rules:
- One default agent workflow. The gateway decides which workflow answers each agent interface
(
agents.default_workflow.<interface>; the shippedbasic-agentfor AbstractCode until you choose another). Clients list Gateway default first and follow a change at the next turn. - A workspace you can see, with built-in protection. An agent works in a folder on the
gateway's computer; AbstractCode's Files tab and
/filesshow its absolute path and preview its files. Credential folders (~/.ssh,~/.aws, …) and the gateway's data folder are denied to every run. - Curated skills. The skill shelf that ships with
abstractskillis copied into the gateway's data folder at each start, without overwriting your edits (skills.shelfpoints elsewhere). - Live replies. Watch answers as the model writes them: the gateway's
agents.streaming_defaultplus a Stream replies choice in each client. - The Assistant, signed in for you. Open in the gateway console starts the desktop Assistant already signed in; no token to type.
- About everywhere. Every app's About screen shows the framework identity and the versions
the connected gateway runs (
GET /api/gateway/about). - Clean model eject. Ejecting a model frees it from the whole gateway process (MLX, GGUF, transformers, embeddings); the console shows the memory the process holds and how it was measured.
Each setting is available in the web console, the terminal console and abstractgateway config.
See Agent sessions.
AbstractFlow lets you author complex agentic orchestration as portable .flow bundles:
- Open the Flow Editor (
npx @abstractframework/flow) - Build a workflow: LLM steps, tool steps, branching, loops, subflows
- Export a
.flowbundle into your own bundle directory and pointABSTRACTGATEWAY_FLOWS_DIRat it (or publish it through the Gateway API) - 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.
- 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
The ecosystem, grouped by layer. Each name links to the package's repository.
| Package | What it is |
|---|---|
| abstractcore | Unified LLM interface: 9+ providers, tools, structured output, media, embeddings, /v1 server, capability plugins |
| abstractsemantics | Central semantics registry (predicates + entity types) with JSON-Schema helpers |
| abstractmemory | Durable, append-only agent memory: usage-weighted graph + journal — recall, formation, consolidation (the entity mind engine) |
| Package | What it is |
|---|---|
| abstractruntime | Durable execution kernel: runs, effects, waits, append-only ledger, artifacts; the VisualFlow compiler (visual graphs → executable workflows); the entity identity lane (homes, chat/life/visit drivers) |
| abstractagent | Agent patterns (ReAct / CodeAct / MemAct) composing Runtime + Core |
| abstractflow | Visual workflow editor + portable .flow bundles — author once, run anywhere |
| Package | What it is |
|---|---|
| abstractgateway | Deployable control plane: durable runs over HTTP/SSE, scheduling + run commands (cancel/steer), workflow catalog, artifact/ledger serving, multi-user auth with per-user runtimes, the summoned-entity lifecycle (create / summon / visit / state / blueprint), and the operator consoles (web + TUI) |
| Package | What it is |
|---|---|
| abstractvoice | Voice I/O (TTS / STT), local and remote backends |
| abstractvision | Model-agnostic generative vision (images, optional video) |
| abstractmusic | Text-to-music / text-to-audio (Core capability plugin) |
| abstract3d | Local-first 3D generation |
| abstractcamera | Camera control and capture tools |
abstractsound, abstractvideo, abstractspatial, abstractgeometry, abstractcognition |
Reserved capability packages (namespaces held; APIs landing incrementally) |
| App | What it does | Install |
|---|---|---|
| AbstractCode | Terminal agentic dev client (Rust, on the AbstractTUI engine) — durable sessions, tool approvals, the gateway's default workflow, workspace files, live replies | cargo install abstractcode, or a prebuilt binary from the GitHub release |
| AbstractAssistant | macOS tray client — gateway-native, follows the gateway's default workflow or your pick, live replies, voice support | pip install abstractassistant, or Open in the gateway console (starts it signed in) |
| AbstractObserver | Browser UI — monitor, control, and schedule gateway runs | npx @abstractframework/observer |
| AbstractEntity | Summoned-entity manager — roster, blueprint (cognition map + editing), chat drawer, live replay | npx @abstractframework/entity |
| AbstractContinuum | Continuous iterative development and deployment console | npx @abstractframework/continuum |
| Gateway consoles | Operator consoles for a running gateway: web at /console (first-run guide, Models, Engines, providers, users), terminal via abstractgateway-console |
built into abstractgateway; cargo install abstractgateway-console |
| Core consoles | Consoles for AbstractCore: web at /console of abstractcore serve, terminal via abstractcore-console (config, Models, Engines) |
built into abstractcore; cargo install abstractcore-console |
| Code Web UI | Browser client of AbstractCode (gateway-backed): workflow selector, Files tab, live replies | npx @abstractframework/code |
| Flow Editor | Visual workflow authoring in the browser | npx @abstractframework/flow |
| Package | What it is |
|---|---|
| abstracttui | Rust terminal-UI engine built on fine-grained reactive signals |
| abstractuic | Reusable UI kit for framework clients (React components + Web Components): chat panel with live replies, the shared About dialog, the app-server proxy |
| abstractskill | Shared library for Agent Skills (SKILL.md folders: load, trust-gate, activate) and the curated skill shelf the gateway serves |
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 abstractframeworkApple — 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]"| Profile | Command | Platforms | Python |
|---|---|---|---|
| Light | pip install abstractframework |
macOS, Linux, Windows | 3.10–3.13 |
| Apple | pip install "abstractframework[apple]" |
macOS 14+ on Apple Silicon | 3.10–3.13 (F5-TTS voice cloning needs 3.11+) |
| GPU | pip install "abstractframework[gpu]" |
Linux / Windows with a CUDA or ROCm GPU | 3.10–3.13 (F5-TTS voice cloning needs 3.11+) |
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.
| Registry | Package | Version |
|---|---|---|
| PyPI | abstractgateway |
0.5.1 |
| PyPI | abstractassistant |
0.6.1 |
| PyPI | abstractcore |
2.16.1 |
| PyPI | AbstractRuntime |
0.5.1 |
| PyPI | abstractagent |
0.3.15 |
| PyPI | abstractskill |
0.3.0 |
| PyPI | AbstractMemory |
0.3.0 |
| PyPI | abstractsemantics |
0.0.5 |
| PyPI | abstractvoice |
0.11.4 |
| PyPI | abstractvision |
0.3.29 |
| PyPI | abstractmusic |
0.1.15 |
| npm | @abstractframework/flow |
0.3.21 |
| npm | @abstractframework/code |
0.5.0 |
| npm | @abstractframework/observer |
0.1.13 |
| npm | @abstractframework/continuum |
0.3.2 |
| npm | @abstractframework/entity |
0.2.2 |
| crates.io | abstractcode |
0.6.0 |
| crates.io | abstractgateway-console |
0.9.0 |
| crates.io | abstractcore-console |
0.2.0 |
| crates.io | abstracttui |
0.6.0 |
| GHCR | ghcr.io/lpalbou/abstractgateway |
0.5.1 (gpu-latest / <version>-gpu experimental) |
| GHCR | ghcr.io/lpalbou/abstractcore-server |
2.16.1 |
Optional add-ons that are not part of any profile install separately:
pip install abstract3d (0.3.1) and pip install abstractcamera (0.2.0). abstractskill (pinned above)
comes with the gateway, which carries its curated skill shelf; install it on its own with
pip install abstractskill.
See docs/install.md for the full install chooser, uv/venv guidance,
abstractframework doctor, and the generated installer manifest contract.
| Page | What it covers |
|---|---|
| docs/README.md | Documentation hub — pick your starting point |
| docs/install.md | Light / Apple / GPU install chooser and first checks |
| docs/getting-started.md | Two entry points + first end-to-end run |
| docs/agent-sessions.md | Default agent workflow, the conversation workspace and its protection, skills, live replies, the Assistant hand-over |
| docs/architecture.md | Component diagram, how a turn flows, the live-reply lane, app proxies, model eject, framework identity, durable execution primitives |
| docs/configuration.md | Minimal config, where defaults live, Core vs Gateway |
| docs/glossary.md | Shared terminology (run, ledger, effect, wait, bundle, …) |
| docs/faq.md | Common questions, comparisons, limits |
| docs/troubleshooting.md | Symptoms, checks and fixes for install, sign-in, network and provider problems |
| docs/api.md | Meta-package API (pins, helpers, re-exports, abstractframework doctor) |
| docs/workspace-scripts.md | Working from source: package tiers, build, status, pull/commit/push scripts |
| CHANGELOG.md | Release history of the meta-package and its pins |
| CONTRIBUTING.md | How to work on this repository and propose changes |
| SECURITY.md | How to report a vulnerability |
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 tierKeep 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 dependenciesMIT. See LICENSE. Credits: ACKNOWLEDGEMENTS.md. Community expectations: CODE_OF_CONDUCT.md.