Probabilistic models cannot be governed by text alone. They require deterministic architecture.

Why agent-based infrastructure?

Every layer of infrastructure earned its place by killing one specific kind of uncertainty. You already know the sentence that made you adopt each one.

Containers ended works on my machine. Orchestrators ended manual placement. Infrastructure-as-code ended undocumented drift. Agents introduced a new one, and it is the worst of the set: a system whose next action is a probability.

That uncertainty doesn’t get solved by a better prompt, a bigger model, or another retry loop — those make the system more capable, not more predictable. It gets solved the way every layer before it did: by moving the decision out of the thing that guesses and into code you can read, review, and diff.

That is the entire reason ABI-Core exists.

The model never decides execution order. Your code does.

ABI-Core is an open-source Python framework for multi-agent systems that behave like infrastructure instead of like a prompt that happened to work. You write plain async functions; ABI packages them into services, wires the messaging, registers them for discovery, and enforces the rules. Execution order is declared with depends_on — steps at the same level run in parallel, and nothing runs because a model felt like it.

# these two have no dependency between them — they run in parallel
@agent.step(name="classify")
async def classify(raw_input): ...

@agent.step(name="validate")
async def validate(raw_input): ...

# this one waits for both. the graph is code, not inference.
@agent.step(name="decide", depends_on=["classify", "validate"],
            input_map={"cls": "$classify.result", "ok": "$validate.result"})
async def decide(cls, ok): ...

Pick models by capability, not by benchmark. alpha

ABI profiles a task by what it requires and a model by what it provides, across seven dimensions — including instruction_following, which is why a small model often makes the better orchestrator and a large one keeps trying to solve the problem itself. Profiles are measured with a deterministic probe battery and Wilson confidence intervals. No LLM judging another LLM.

Alpha. This subsystem is earlier than the rest of the framework: the probes run and the selector works, but the capability API and the seven dimensions are still moving and will change between releases. Treat it as a research surface, not a stable contract.

abi-core capabilities profile qwen2.5:3b --output profiles.json
abi-core capabilities show qwen2.5:3b --source profiles.json

Built and maintained by Joselo Martínez.

Most agent systems don’t fail because the model is weak. They fail because a research prototype was handed to production without a state model, a failure domain, or a way to answer “what exactly did it do, and why?”

Fifteen years in distributed systems, now spent entirely on the layer between the model and the rest of your infrastructure: orchestration, tool contracts, blast radius, observability, and the governance a compliance team will actually accept. This is the call you make when your orchestration layer starts failing in ways your traces can’t explain.

ABI-Core is the working proof: signed agent-to-agent messages, per-agent tool permissions, a risk-scored audit trail, and a human veto before execution — shipped continuously since November 2025 and released under Apache-2.0.

Designed, not magic.

The thinking behind the framework, published in the open.