One API for each kind of work, done by the program the person chooses.

package main

import (
    "context"
    "fmt"
    "log"
    "time"

    facade "github.com/openabstractions/abstraction-facade/go"
    wire "github.com/openabstractions/abstraction-inference/go/abstraction/inference/api"
)

func main() {
    ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
    defer cancel()
    chat, err := facade.Discover().ResolveInference(ctx, facade.Requirements{})
    if err != nil {
        log.Fatal(err)
    }
    reply, err := chat.Complete(ctx, wire.Request{
        Model: "qwen3:8b",
        Messages: []wire.Message{{Role: wire.RoleUser, Parts: []wire.Part{
            {Kind: wire.PartKindText, Text: "Say hello in five words."},
        }}},
    })
    if err != nil {
        log.Fatal(err)
    }
    if reply.Outcome != wire.ReplyOutcomeCompleted {
        log.Fatalf("chat %s: %s", reply.Outcome, reply.Reason)
    }
    for _, part := range reply.Message.Parts {
        fmt.Print(part.Text)
    }
}

import time

import abstraction.inference.api as api
from abstraction.facade.client import Machine

machine = Machine(deadline=time.monotonic() + 30)
chat = machine.resolve_inference()
reply = chat.complete(api.Request(
    model="qwen3:8b",
    messages=[api.Message(role=api.Role.USER, parts=[
        api.Part(kind=api.PartKind.TEXT, text="Say hello in five words."),
    ])],
))
if reply.outcome != api.ReplyOutcome.COMPLETED:
    raise SystemExit(f"chat {reply.outcome.value}: {reply.reason}")
print("".join(part.text for part in reply.message.parts))