BaselithCore

The Research-Backed Engine for Production-Grade Agentic AI.

BaselithCore is a high-performance orchestration engine designed to transition agentic AI from experimental prototypes to resilient, production-ready infrastructure. Built on a modular architecture, it provides an agnostic foundation for engineering scalable multi-agent systems.

Why BaselithCore

• Agents that survive production. Durable execution with checkpoint/resume, replayable tool steps, state history and fork/rewind — a crash mid-run recovers without duplicating 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 compliance primitives.

Ten lines to a working multi-agent pipeline — typed, budgeted, observable:

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

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

The full deep-dive lives in the architecture docs.

Core Philosophy

1. Sacred Core: The core/ directory contains exclusively agnostic logic — orchestration, infrastructure, utilities. No domain code, ever.
2. Plugin-First: All business logic, integrations, and specialized capabilities live in Plugins, so secondary features never bloat the engine.
3. Agentic by Design: The Agentic Design Patterns (Memory, Reflection, Tool Use, Planning, …) are baked into the orchestrator, not bolted on.

What's Inside

Every capability ships production-hardened: typed, tested, observable, and fail-closed by default.

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 — see the installation guide for the full list, and the quickstart to build your first agent.

Resources

Contributing & License

We welcome contributions that adhere to our code standards. Please review CONTRIBUTING.md.

BaselithCore is licensed under the GNU Affero General Public License v3.0 only (AGPL-3.0-only). See LICENSE for full details.

Writing a plugin? You keep your source. The BaselithCore Plugin 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.