Find a capability, contract, or method

Shared vocabulary

Terms used across capabilities

Words you'll meet first

Runtime

The OA background service installed on the machine. Every application talks to this one program.

Client library (facade)

The OA library an application adds to find the runtime and get a typed client for each capability.

Provider

The program that does the work behind a capability, such as curl for a download or Ollama for a model call.

Capability

One kind of work OA offers through one API, such as downloads, jobs, model calls or questions to the person.

Operator

The person who runs the machine, acting at the command line or in the Panel.

Permission

What an application may do on this machine, which the person allows or blocks per program.

Question

A request for a person's decision. Applications present their ordinary choices; OA presents its permission requests. The service retains pending and answer state.

Job

Work the runtime accepted and keeps running after the application closes, with progress and a result to read later.

Lease

A time-limited claim on a scarce resource, such as graphics memory, that its holder gives back when asked.

Card

A graphics card's memory; card:0 names the first one.

Adopter

An application that uses OA, such as OpenCode or ComfyUI with their OA integrations.

CAS (compare-and-set)

OA's small-file update that writes only when the file still holds the value the writer last read. Content-addressed storage is the storage module's job.

All terms

Abstraction

A stable concept and API whose meaning holds across operating systems, libraries, engines, and service providers. Each abstraction can be adopted independently.

Capability

The work an application asks OA to supply, such as reading content, submitting durable work, routing a model, or asking a user a question. One or more modules implement a capability as a service.

Module

One repository under openabstractions-flat/abstraction-*, stacked so a higher module builds on a lower one's guarantees, such as the model module resolving a reference before the download module moves bytes.

Service

A named wire interface and behavioral version, such as abstraction.logging/sink@1, and the endpoint inside the runtime that answers its calls — one word for the interface and the thing that answers it, as gRPC uses it. Distinct from a contract, the numbered rule set that defines its promises and limits. In the module catalogue, service is the Kind a module's definition earns by declaring a service that is not direct.

Provider

An implementation behind a capability contract that the runtime mediates. Some run inside the runtime, such as the download module's transfer agent; others are registered programs the runtime launches or attaches to, such as inventoryd, which indexes what a machine already holds, or lemonaded, which serves images, transcription and speech. In the module catalogue, provider is also a Kind value: a module named <x>-over-<y> with a command, or one whose definition declares guarantees and no service.

Runtime

The installed OA program selected for the connected local account and program. It resolves capabilities, enforces rights, owns service state, and mediates providers. It is one program, openabstractions serve runtime: installed, the platform's service manager starts it as the background service; run directly, the same command starts it in the foreground. On Windows the per-user supervisor, openabstractions serve supervisor, starts it and restarts it after a failure.

Facade

The shared entry point used to resolve typed capability clients. Machine selects and trusts the local runtime; Resolve… methods return a bound client.

Contract page

A module's CONTRACT.md: the document stating a contract's obligations, admission order and refusal reasons. Its rule ids, such as INF-A1, are what tests and refusals cite.

Requirements

The guarantees and execution placement requested during resolution. The runtime returns an eligible binding or a typed refusal.

Guarantees

Contract-specific promises required before work starts, such as recovery across caller exit. Accepted work keeps the guarantees under which it was admitted.

Placement

Requested execution location during resolution: local, remote, or any where the capability supports it; the resolved endpoint has a fixed placement.

Subject

The account-plus-program a decision, or a job's ownership, is about. A job's subject observes, lists, reads and cancels what it submitted, with no rule consulted for that; rights and identity read the same subject when deciding or verifying a peer.

Binding

The resolved client-to-service tie: in the facade, the capability, service, provider revision, transport, endpoint, placement, and guarantees a continuation call validates against. Identity's peer answer (Bind/BindConn) takes once at accept and freezes, refusing a later re-derivation.

Idempotency key

A stable caller-owned key created before submission; a retry with the same key reconciles the same job instead of starting a new one.

Job

The module that gives submitted work a durable identity, acceptance, reconciliation, cancellation, and inventory: abstraction-job. Other capabilities submit through it rather than each tracking accepted work of their own. An accepted job is work a service owns; its receipt records the job identifier, logical owner, idempotency key, binding, and accepted guarantees.

Peer identity

Operating-system evidence about the connected account, process, executable, package, and code identity. Each attribute carries its proof strength.

Rights

Policy decisions for an action on a resource by a verified peer. The service that owns the resource enforces the decision.

Budget

A credential's daily spend cap, checked before a hosted call starts. A request over an exhausted budget refuses budget_exceeded.

Ceiling

The strongest proof identity can bind for an attribute.

Application manifest

An operator-installed record naming an application, its executable, display title, start guidance and optional activation recipe. A running instance announces its interfaces separately.

Application instance

A leased OA handle returned when a ready application announces itself. Renewals keep that exact instance present until withdrawal or expiry.

Application context

An application-owned document or workflow name, title, and revision. Interaction adapters use the revision to reject a call aimed at an older target.

MCP gateway

An authorized integration program that exposes a curated set of OA-backed tools to a Model Context Protocol client. Its operating-system identity determines its OA rights.

Work

What a person or application wants OA to do, before it is submitted: the plain word for the thing a job accepts and records.

Store

Where a provider keeps content. OA storage offers content-addressed objects and a combined inventory of available stores. Its local-stores provider can discover model files managed by other applications. Writes to OA-managed content use content-writer@1.

State file

The CAS state file: the lock-guarded shared state abstraction-cas maintains.

Share

A shared folder on a NAS.

Handle

An open read handle in storage, such as a POSIX file handle or a Windows HANDLE.

Sink

A destination for structured log records, exposed through abstraction.logging/sink@1. Default handlers resolve an OA logging service and report resolution failures. After a service outage, they retry with a bounded queue and report dropped records. Local fallback requires explicit provider selection.

Destination

Where a download writes bytes: a plain path outside the content store, named by the caller for a deprecated in-process download (download.Open()/Get()) and by the runtime for a job-service download, to its own result document. It never names the store.

Family

The canonical identity two names for the same weights must agree on before one of them can answer for the other, resolved by the model module. The router reads a family as the cluster of a model server's own aliases resolved to that identity, together with which servers and stores hold each one.

Lease

One axis, two senses. A resource lease (abstraction.resource/leases@1) is asked back with a deadline, renewed while the holder keeps using it, and given back when the holder yields. A job's lease is exclusive, carries an epoch, and is never asked back; job states it with the job (JOB-L1).

Yield

Giving a resource back on the service's request: a lease holder yields through Answer; an attached holder yields through its server's own unload. What the instrument shows afterwards is the answer. An engine's own eviction is not a yield.

Resident

Loaded and currently answering calls, said of a model a model server or a model host provider is holding in memory under a lease.

Model server

A declared model runtime or provider endpoint this machine or an operator names — Ollama, LM Studio, Lemonade, or a hosted server such as OpenRouter. Registered through inference server add (inference host add until the next release) and addressed by a rights rule as host:<name> (renamed to server:<name> on the wire in a later release). abstraction-provider-modelhost's own process, which loads a model file into an engine and keeps it resident, is declared to the runtime the same way, as host:modelhost.

Host

The address part of a URL: the machine a transport connects to, as in OLLAMA_HOST or a --host flag. Distinct from a model server.

Claimed

An unverified, self-reported assertion, with no verification behind it: a peer attribute the peer itself asserted (identity's lowest proof level), a log hop the writer itself asserted (its lowest attestation standing), or a resource-table row an engine or its adapter self-reported (with no instrument behind the amount).

Location

One location in config's precedence ladder — machine, user, or process — ordered nearest first; the nearer location's value wins, and every answer carries the location it came from.

Resource

A named target for rights and for the resource module alike: credential:<name> or account as a rights target; card:<n> for an accelerator's memory (cuda:0 on CUDA, a DirectML adapter, or DRM card0), memory for system memory, or awake, the pool a wake lease claims, as one of the machine's scarce pools.

Holder

The program holding a lease or a resource amount.

Hold

One row of the resource table: an account, a program, a resource, and an amount, whether measured or claimed. A holder in two processes is two holds.

Credential manager

The abstraction.credentials/manager@1 service that registers, rotates, revokes, lists, and audits named secrets.

Operator

A person acting at the command line or the Panel, distinct from an application. Also the generated *Operator services (abstraction.rights/operator@1, abstraction.asks/operator@1, and others) that such a person, or a program the installation trusts as one, reaches through an explicitly authorized typed-peer callback.

Deprecated

A still-shipped earlier interface, each kept with its removal release named, or without one until then. The embedded file-reading config provider (Go config.go, Python python/abstraction_config.py) is kept for a deliberate out-of-tree adopter that reads configuration files directly instead of the service; Load, Watch, and JobStore are its deprecated names. Job's file-backed record interface (Store, shipped as NewFileStore) is deprecated the same way.

Inference gateway

A loopback OpenAI- and Anthropic-shaped listener on the runtime, for a program that only knows a base URL and an API key. It stays off by default; an issued gateway key binds one program.

Gateway key

The key the inference gateway issues to one program so it can reach the runtime through the gateway. A hosted server's own credential is instead called an API key.

Alias

A model's name as a model server reports it. Used as a family's identity when no store descriptor names one (family_source: alias); an alias reaches a store's own name for the same content by one matching function.

Servable

Able to serve a request for a model, unlike a store that only holds it. A component such as a projector or a VAE is never servable on its own.

Up

Whether a hosted server's listing could be read. False, with a why reason, when its credential could not be applied or its wire kind is unsupported.

Hosted

A model server reached off this machine rather than resolved locally. Pick's hosted outcome names one answering instead of a local server; its entry names a base URL, a wire kind, and a credential name.

Held in

The storage inventory stores holding an object a family or alias matches, in store order; empty when no configured store reports the model.

Domain

The remote runtime name a listed server answers through, distinguishing a remote runtime's own servers from this machine's.

Instrument

The platform mechanism that measures a resource's holders, such as Windows' GPU process memory counters. A row above its declared threshold is measured; below it, or with no instrument for a resource, the row is claimed.

Engine

The program that loads model weights and answers calls, such as llama-server, sd-server or Lemonade. A provider module wraps an engine the machine has, or OA supplies one as its own registered provider process. The model host and the Lemonade provider run publishers' pinned builds staged from archives a person or Setup downloads, and the model host's PyTorch engine, which OA wrote, is moving into its own provider module.

Lend

Writing a link into another application's engine directory so that engine serves an object already in a store, gated by abstraction.storage/lend@1. Never a move, a rename, or a deletion.

Ledger

The record of which lends are in force, oldest first; replaced in one rename, so a reader sees a whole ledger or the one before it. It says whether a lend is in force, not the engine's own list.

Object

A store's content, named the way the storage inventory names it: a store and an id, never a path.

Locator

An object's location a store reports when it published no manifest id; the ledger records the manifest id where the source published one, and the locator otherwise.

Inventory

The composed, read-only list of what objects a machine's stores hold, served by abstraction.storage/inventory@1 from designated abstraction.storage/inventory-source@1 providers, such as local-stores' own indexer.

Storage class

A retention promise: data, cache, tmp, or logs.

Retention

How long a class keeps an object once nothing holds it.

Max use

The most bytes a class may occupy.

Collector

The runtime's process that removes what a class no longer promises to keep.

Low free space

The collector's pressure trigger: 15% of the file system, capped at 4G.

Purgeable

A cache object marked for the platform cleaner.

No-backup

A folder's or object's attribute excluding it from backup.

Adopter

An application that calls OA's abstractions, such as OpenCode or ComfyUI through their OA integrations. OA publishes labelled, versioned builds of some adopters.

Question

A service-held request with offered answers. Legacy application@1 uses a fixed catalogue; ordinary application@2 carries app-authored choices with explicit replay bounds. Ordinary answers select app behavior; first-use permission answers have exact Rights effects.

Rule

A stored authorization entry: a subject, an action, a resource, and permit or deny. Contracts say rule; the Panel and this site say permission.

Permission

A rule as the Panel shows it, with Allow and Block for permit and deny.

Responder

A program a person lets answer first-use questions on their behalf through abstraction.asks/responder@1, under an exact rule that expires. It never answers a question about itself.

Modality

What a model server serves: chat, embed, transcription, speech, image, video or live. The wire still says profile, as in profile:image, until its next service version.

Content scope

The content an application may write and read for one kind of input or output, such as output:image for generated pictures or input:audio for audio to transcribe. One first-use allow writes both rights on it.

Provider kit

The shared Go packages under abstraction-inference/go/providerhost that provider programs build on: engine-file proofs, clean launch environments, loopback checks, and request checks for engines such as sd-server.

Awake

The wake level that keeps the system on, held as a wake lease on the resource awake. Today the lease takes a platform request only while its holder also holds a card lease, and that request keeps the display on as well. In 0.4.0 a provider that declares a card holds it for the work it serves, a provisional exception that a lease held for the requesting application replaces after research.

Awake (display)

awake:display, the wake level that keeps the display on and holds off the screen saver and automatic lock. Decided as its own rule per application and not built yet.

Selection policy

A saved, ordered list of eligible models and model servers for one account and program. A chat@2 or image@2 request names one in place of a model, and the runtime picks an available candidate from it.

Preset

The generation settings a provider keeps for a model, such as steps, guidance, scheduler and size. A caller who wants another preset names another model.

Service lifecycle

From a requirement to a bound call

1. Connect. A language facade selects the installed runtime for the current account and establishes the shared native IPC transport.
2. Resolve. The client sends a capability, accepted services, guarantees, and placement to Resolver.Resolve.
3. Authorize and select. The runtime identifies the caller, checks policy, and selects an eligible ready candidate.
4. Bind. A generated client receives a service reference with one contract, endpoint, placement, and provider binding.
5. Call. The generated client validates records and uses the shared transport. The OA service owns downstream provider connections and credentials.
6. Continue. Accepted jobs remain associated with their original owner and binding. Observation, cancellation, and reconciliation use that association.

machine := facade.Discover()
logs, err := machine.ResolveLog(ctx, facade.Requirements{
    Scope: facade.ScopeLocal,
})
if err != nil { /* inspect the typed binding error */ }
logs.Write(record)

A later resolution may choose another eligible provider. An existing binding stays specific to the selected service. The facade contract defines resolution, trust, and binding behavior.

Authority

Identity, rights, and execution are separate facts

Caller-supplied labels remain metadata. Provider names, model names, MCP client names, application titles, and context titles carry no identity authority. Credential values stay in the credential service and are applied to an exact target through Applier.Check and Applier.Apply.

Durable work

Acceptance, observation, and recovery

The job contract defines accepted-work ownership, reconciliation, explicit cancellation, retained results, and inventory bounds.

Applications and assistants

Directory metadata, activation, and tools have distinct roles

These methods belong to abstraction.facade/applications@2. An interface entry describes an application-owned protocol such as comfy.presentation@1. Metadata does not invoke that protocol.

An application interaction adapter implements the protocol and preserves the selected instance, context, and revision through preview, apply, and readback. A stale revision refuses an outdated target. This adapter is specific to the application interface.

An MCP gateway maps a curated tool set onto OA clients and application adapters. The MCP gateway runs as its own verified integration subject and receives explicit rights. It exposes a selected tool set rather than generic forwarding to arbitrary MCP servers or application methods.

Failure and recovery

Read the typed result before retrying

Each contract owns its exact enum and recovery rule. The table is a navigation aid across recurring meanings.

API index

Capability APIs and the application directory

Method names below come from the current Thrift definitions and generated Go facade. Direct utilities are marked separately.

q, err := facade.Discover().ResolveAsks(ctx, facade.Requirements{})
obs, err := q.AskContext(ctx, asks.ApplicationQuestion{
	RequestKey: "dl-example.com", Key: "download.reach",
	Slots: map[string]string{"host": "example.com"}})
fmt.Println(obs.Outcome) // "pending" until a person answers

cfg, err := facade.Discover().ResolveConfig(ctx, facade.Requirements{})
snapshot, err := cfg.ReadContext(ctx)
fmt.Println(snapshot.Store, snapshot.Origins.Store.Rung)

holder, err := facade.Discover().ResolveCredentials(ctx, facade.Requirements{})
page, err := holder.List(ctx, "", 32)
fmt.Println(page.Records)

chat, err := facade.Discover().ResolveInference(ctx, facade.Requirements{})
// forbidden here is the resolution boundary's own peer check, not a missing grant
reply, err := chat.Complete(ctx, wire.Request{Model: "llama3.1", Messages: msgs})
fmt.Println(reply.Outcome) // not_permitted is a missing per-server grant, CONTRACT.md INF-A2

openabstractions inference gateway on --address 127.0.0.1:8765
openabstractions inference key issue --for /absolute/path/to/curl
curl http://127.0.0.1:8765/v1/chat/completions -H "Authorization: Bearer oalk_..." \
  -d '{"model":"llama3.1","messages":[{"role":"user","content":"Say hello in five words."}]}'

logs, err := facade.Discover().ResolveLog(ctx, facade.Requirements{})
err = logs.LogContext(ctx, 0, "worker started", map[string]string{"component": "indexer"})

Generated schemas

Every contract's generated reference page

Each page below comes from that contract's Thrift definition through the shared docs generator, one page per contract. The rule tags cite the contract's CONTRACT.md.

AI on this machine

Foundations

Inference detail

Modality profiles and methods

Live voice is the live@1 service. It carries ordered, bounded session events over native IPC. Vendor connections and credentials remain inside the inference service.

Requests and presentation

App choices, OA permissions and notification actions

Applications show ordinary choices in their own UI. OA keeps shared pending and answer state and presents its permission requests. Notifications with actions form a separate planned native surface.

The permission journey connects two identified apps, native consent, a saved rule and an actual credential-bearing operation. Identity binds the calling program, Rights decides access, Asks retains the proposed decision and answer, and the resource service checks and performs the operation. The canonical guide preserves the research basis, accepted one/all scope and finite full-control design; the runnable Windows/macOS playground and human captures remain pending.

Development source for 0.4.0, October 5, 2026. Released 0.3.0 has its own contents and package evidence. Automatic OA ordinary popups are removed; caller-scoped Answer/Dismiss and the Go terminal example are integrated. Fresh native Mac verification and ordinary agent answering remain open.

Native appearance follows the actual OS version: Windows 10, Windows 11 or AppKit on macOS. The Windows 11 renderer has bounded expanded details and compact chrome. Successful permission answers finish without a second confirmation dialog; failed or uncertain completion retains its report.

Synthetic native lifetime/answer guards and result-report checks passed for the compact Windows 11 source through 957df22bd, using a fake Rights owner. The owner's screenshot shows earlier baseline 3c3b31abf; final appearance of the compact revision remains unaccepted. Keyboard/UIA, cross-monitor DPI/high contrast, Windows 10 appearance, actual owner Mac answering/effect/Undo, lock/unlock, installed login/upgrade and 0.4.0 release qualification remain open.

Planned system access permissions explain a protected system act and use the operating system's administrator approval when required. Planned privacy access permissions explain the device or data capability and follow its platform-specific consent and Settings path. Windows owns actual UAC approval and its secure desktop.

A stable action code and structured resource identify authority. Readable descriptions and display groups explain it. Routine, sensitive and administrative tiers decide who may answer under the existing first-use policy; an administrative OA tier alone supplies no OS elevation requirement. Publisher verification describes recorded identity evidence, with an unverified publisher indicating an evidence gap.

The accepted common permission schema defines explicit operations and typed targets. Source e5c1eebb1 integrates 34 compiled built-in action definitions, the Credentials-owned typed named Use resource and shared native/web first-use explanations. Named Use follows the current account-owned name slot through rotation or recreated registration, under its current host/consumer restrictions.

An isolated native IPC/loopback test passed missing permission → exact caller-bound ask → recorded Allow/applied permit → retry using the named secret. The fixture answered through the operator API; human native interaction retains its separate limits above. Typed one/all selectors, versioned full control, breadth-warning presentation, raw secret Read and the protected OS helper remain unimplemented. Breadth warnings describe scope separately from actual OS elevation.

The Go terminal example prints the full destination, submits its own selection and observes the retained service winner before its guarded output effect. Its suite and Windows redirected-input runtime checks passed; actual console typing remains manual acceptance, and Linux/macOS checks are compile-only.

Ordinary answers select app behavior and grant no OA permission. The proven requester can Answer/Dismiss only its own immutable RequestRef; account-wide answering requires an explicitly authorized operator. Program attribution establishes no human presence. Acknowledge confirms an exact existing answer and relinquishes full service replay. Routine first-use responder enrollment supplies no ordinary answering authority. See ASK-A9, ASK-W5 and ASK-O9 for the current service boundaries.

On-demand desktop Panel

The Panel, section by section

The Panel installs with the runtime and opens as a native window on Windows, macOS and Linux. Each of its sections links to its own anchor below: a "Learn more" link on Windows, a small "?" mark next to the heading on macOS and Linux, and a round "?" button for the current page as a whole. Every anchor names what the section does, the contract rule that decides it, and its command-line equivalent where one exists today.

Status

Work

Questions and permissions

Device

Inference

Providers

Credentials

Settings, logging, identity and explore

Compare the APIs

The same event in your language

These examples write a structured log event through an already resolved client. Select a language to compare its native API. The calling application handles any returned error or exception.

import (
    "context"
    "log/slog"
    logging "github.com/openabstractions/abstraction-logging/go/client"
)

func recordStart(ctx context.Context, events *logging.Client) error {
    return events.LogContext(ctx, int64(slog.LevelInfo), "worker started",
        map[string]string{"component": "worker"})
}

from datetime import datetime, timezone
from abstraction.logging import Record, Sink

def record_start(events: Sink) -> None:
    events.write(Record(
        schema=1,
        time=datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%S.%fZ"),
        level=0,
        msg="worker started",
        attrs={"component": "worker"},
    ))

#include <abstraction/logging/client.hpp>

void record_start(const abstraction::logging::Logger& events) {
    events.log(0, "worker started", {{"component", "worker"}});
}

use abstraction_logging_api::{Record, Sink};

fn record_start<S: Sink>(events: &S, timestamp: String) -> Result<(), S::Error> {
    events.write(Record {
        schema: 1,
        time: timestamp,
        level: 0,
        msg: "worker started".into(),
        attrs: [("component".into(), "worker".into())].into(),
        ..Default::default()
    })
}

import {newRecord} from '@openabstractions/logging';

/** @param {import('@openabstractions/logging').SinkClient} events */
async function recordStart(events) {
    const record = newRecord();
    record.schema = 1n;
    record.time = new Date().toISOString();
    record.level = 0n;
    record.msg = "worker started";
    record.attrs = {component: "worker"};
    await events.write(record);
}

One-way logging confirms local submission. A storage receipt is not returned. For connection setup, use the language guides. For other operations, open the capability’s generated schema in the API index.

Client languages

Facade guides and generated schemas

API presence and platform qualification differ by language and capability. Check current coverage before choosing a client path.