BaselithCore

Agents that survive production. Durable execution, enforced budgets, and EU AI Act evidence — self-hosted, with no companion SaaS.

BaselithCore is a Python orchestration engine for agentic AI. Execution state is checkpointed as a run proceeds, so an interrupted process resumes from its last completed step instead of replaying side effects. Every request carries a budget that caps iterations, tool calls, tokens and USD spend, and every step emits OpenTelemetry spans and Prometheus metrics with real cost attached. The audit trail a regulated deployment has to produce is written while the system runs, not reconstructed from logs afterwards.

Writing a plugin? You keep your source. The plugin exception lets any plugin that uses the framework as a library ship under any licence you like, including a closed one. Same terms for everyone.

Why BaselithCore

• Agents that survive production. Durable execution with checkpoint/resume, replayable tool steps, state history and fork/rewind — a SIGKILL mid-run recovers without repeating a single side effect.
• Everything included, nothing rented. Evaluation suites, LLM-as-judge, red-teaming, OpenTelemetry tracing, Prometheus metrics with real USD cost, Helm/Terraform deployment — built in and self-hosted, with no companion SaaS to subscribe to.
• Brakes, not just horsepower. Autonomy gating, durable human-in-the-loop approvals, per-request cost budgets, prompt-injection guardrails, sandboxed code execution — every seam fail-closed by default, plus opt-in EU AI Act / GDPR / NIS2 / DORA primitives with evidence trails.

Sixty seconds

pip install baselith-core

from core.agent import Agent, Crew, Task

researcher = Agent(system_prompt="You are a meticulous researcher.")
writer = Agent(system_prompt="You write crisp executive summaries.")

crew = Crew(agents=[researcher, writer], tasks=[
    Task("Research {topic} and list the key facts.", agent=researcher),
    Task("Write a summary from the research.", agent=writer),
])
report = (await crew.run(inputs={"topic": "vector databases"})).final

Typed, budgeted and observable from the first line — the quickstart adds tools, structured output and a checkpoint store.

Architecture at a glance

graph TD
    subgraph SC["Sacred Core (Agnostic Engine)"]
        A["Core Orchestrator<br/>(intent · routing · adaptive loop · durable checkpoint/resume)"]
        F["Flow Handlers"]

        subgraph COG["Cognitive Layer"]
            RE["Reasoning<br/>(MCTS · Tree-of-Thoughts)"]
            WM["World Model<br/>(risk · rollback · simulation)"]
            SW["Swarm<br/>(auction protocols)"]
            PL["Planning"]
            MT["Meta · Reflection · Adversarial"]
        end

        LP["Engineered Loops<br/>(verifier · stall guard · escalation)"]
        M["Memory Hierarchy<br/>(STM → MTM → LTM)"]
        S["Storage Layer<br/>(Postgres · Qdrant/pgvector · Redis)"]
        R["Plugin Registry"]
        RES["Resilience · Observability · Guardrails"]
    end

    A --> COG
    A --> F
    A --> LP
    A --> M
    M --> S
    COG --> M

    R --> C["Custom Agent Plugins"]
    R --> D["Capability Extensions"]
    R -.->|Inject Handlers| A
    R -.->|Inject Routers| G["API Gateway"]

    A --> H["LLM Layer<br/>(Anthropic · OpenAI · Gemini · Ollama · HF)<br/>native tool-calling · typed output · cross-provider fallback"]
    F --> H

    A --> I["Interop<br/>(MCP · A2A streaming · AP2 mandates · realtime duplex)"]
    A -.->|wrapped by| RES

Two rules hold the shape: core/ stays domain-agnostic, and everything domain-specific is a plugin. The architecture docs go deeper.

Quick start

pip install baselith-core       # core engine
docker compose up -d            # Redis, PostgreSQL, Qdrant (optional)
baselith doctor                 # validate environment and configuration

Optional capabilities (RAG, browser automation, OCR, extra model providers, vector backends, …) install as extras — the installation guide has the full list.

Contributing

Contributions are welcome, and the on-ramps are deliberately marked:

• good first issue — scoped, with context and an acceptance check
• help wanted — bigger pieces that need an owner
• Discussions — questions, ideas, and what you built

CONTRIBUTING.md covers the dev setup, the quality gates your PR has to pass, and the review turnaround you can expect.

Version 0.31.0 ships 6,884 tests at 80% branch coverage, gated in CI at a 75% floor alongside strict typing, architecture-boundary and docs-consistency checks.

Licence

BaselithCore is licensed under the GNU Affero General Public License v3.0 only (AGPL-3.0-only) — see LICENSE.

LICENSE.exception grants an additional permission under AGPL section 7: a plugin that uses the framework as a library — rather than modifying it — may be licensed under any terms you choose, including closed ones, and section 13 never reaches it. The permission is offered to everyone on identical terms. Two conditions come with it: your plugin must carry the notice described in section 3(c), and patching files under core/ makes it a modified framework rather than a plugin, in which case AGPL-3.0-only applies in full. See plugin packaging for what the notice has to say.

Copyright © 2026 BaselithCore Team.