Buffaly

The neurosymbolic engine for safe, controlled, and explainable AI.

Most agents are trapped in a text loop. Handing the keys of our infrastructure to probabilistic language models is a dangerous dead end. Buffaly is the open-source alternative: a revolutionary architecture that learns continuously, rewrites its own code online, and scales safely without flattening the world into text tokens.

Install Buffaly View on GitHub See how it works

Install locally Inspect the source Choose your models Keep your knowledge

Local quickstart

Signed Windows installer

Download Windows MSI Windows installation guide

Checksums & release notes Open the quickstart

An architecture built for what comes next.

The industry is on a dangerous trajectory. We are treating LLMs as control planes, reducing complex reality into massive text prompts, and paying for the size of the context rather than the size of the task. If this is how we scale toward AGI, we are building a house of cards that is structurally vulnerable to prompt injection, hallucination, and run-away costs.

Buffaly is a fundamentally different class of system. It is designed to scale intelligence safely by strictly separating language reasoning from execution. I am open-sourcing this core runtime to give developers a template for how high-trust, self-improving AI should actually be built.

Models are providers

The model is not the system.

Buffaly keeps what your agents learn: the ontology, tools, policies, execution history, and generated code. The reasoning model can change without starting over.

Buffaly keeps

Ontology and typed knowledge
Tools and generated code
Session history and decisions
Policies and data boundaries

The model provides

Language reasoning

- provider: anthropic
+ provider: ollama

Why I released Buffaly

I didn’t want Buffaly to be just another research paper.

Buffaly should not be another abstract claim about neurosymbolic AI. You should be able to install the working system, inspect how it represents knowledge, build tools on it, and decide for yourself where the architecture is strong or weak.

An architecture this consequential should be tested in public, not protected by a demo.

Run Buffaly Inspect the source

Do not take our word for it

Run the actual system

Install Buffaly on infrastructure you control and connect the models you choose.

Open the machinery

Inspect the ontology, typed actions, generated tools, and execution paths behind its answers.

Try to prove it wrong

Build something difficult. Keep what works. Find the limits without waiting for a vendor’s permission.

Memory you can read

Experience becomes executable structure.

Buffaly can promote successful work into typed knowledge and reusable actions. The result is inspectable, editable, and available to the next agent without reconstructing the entire procedure in a prompt.

Read the technical deep dive

ClaimsDenialAppeal.pts

prototype ClaimsDenialAppeal : OperationalCapability
{
    EntityName = "prepare a denial appeal";
    DependsOn = EligibilityEvidence;
    Produces = AppealPacket;
}

prototype ToPrepareDenialAppeal : TypedAction
{
    Input = DeniedClaim;
    Output = AppealPacket;
    RequiresApproval = true;
}

The 5 Pillars of a New Paradigm

Buffaly turns agent behavior into structured,
inspectable runtime capability.

Semantic entities, not static memory.

A normal agent stores facts as notes. Buffaly promotes language into typed objects the runtime can reuse, query, and refine.

As Buffaly sees codes, programs, patients, tools, or workflows used in real tasks, it can move from raw strings into a working object model.

ProtoScript semantic knowledge

[SemanticEntity("remote care program")]
prototype RemoteCareProgram : CareProgram {
    String ProgramCategory = "Remote Care";
}

[SemanticEntity("APCM")]
partial prototype CareProgram#APCM : RemoteCareProgram {
    ProgramCode = "APCM";
    DisplayName = "Advanced Primary Care Management";
}

A self-extending runtime, not just code generation.

Buffaly can turn repeated successful reasoning into new executable actions instead of leaving it as chat output.

When a task repeats at scale, the runtime can close the gap by creating a more specific tool surface.

Generated runtime capability

prototype ToBatchCheckAPCMReadiness : Action {
    function Execute(Collection<Patient> patients) : BatchResult {
        foreach (Patient patient in patients) {
            // Loop natively without model involvement
        }
    }
}

Native object execution, not text-only orchestration.

Instead of serializing everything into prompts, Buffaly binds typed actions to real runtime objects and existing code.

Your business logic stays native. The agent selects the action; the runtime executes the real implementation.

Existing C#

public static class APCMReadinessChecker {
    public static Result Check(Patient patient) {
        return APCMRules.Evaluate(patient);
    }
}

Typed action binding

prototype ToCheckAPCMReadiness : Action {
    function Execute(Patient p) : Result {
        return APCMReadinessChecker.Check(p);
    }
}

Sensitive data stays behind runtime handles.

The safest PHI, secrets, and operational data are the values the model never sees.

Buffaly can reason over typed references while raw data remains in runtime memory and native systems.

Text-loop agent

{
  "name": "John Doe",
  "dob": "1954-03-12",
  "diagnoses": ["E11.9"]
}
// Sensitive data enters context.

Buffaly runtime

Handle: Patient#A17F
Type: Patient
// Raw data stays in runtime memory.

Inverse token economics: intelligence gets cheaper.

Repeated reasoning becomes a tool. Repeated tools become native execution. The model stops orchestrating loops that software can run directly.

79.7% reduction

Decrease in token cost per task once repeated patterns became deterministic code in a real FairPath task.

The system gets more valuable as operational behavior becomes structured capability instead of ever-larger prompt context.

See the measured result

Strategic focus

Built for administrative workflows that cannot afford hallucinations.

Buffaly connects to your existing systems to perform complex administrative tasks with deterministic logic. Every step is reviewable, every action is logged, and no chatbot is left to improvise on your behalf.

Healthcare first

Revenue Cycle Operations

Automate reconciliation, follow-up tasks, and work queue management with rules that integrate directly with your RCM stack.

Insurance & Eligibility

Perform deep coverage checks, stage real-time results, and route exceptions with clear operational evidence.

EOB & Remittance Handling

Normalize inbound remittance files, resolve field discrepancies, and support high-volume exception handling.

Patient Intake & Data Staging

Clean and resolve inbound patient data, preparing it for downstream clinical systems without manual entry.

Audit-Heavy Back-Office Automation

Deploy automation in environments where compliance is the first requirement. Buffaly produces durable audit trails for every decision, making the work ready for regulatory review out of the box.

The origin story

Buffaly started from a different direction.

It began with a simple observation: children do not learn language from language alone.

I read Goodnight Moon and The Very Hungry Caterpillar to my son so many times that I began trying to reproduce in software what I could watch him doing. He connected words to pictures, objects, actions, routines, emotions, mistakes, and corrections. A word was never just a word. Language attached to something outside itself.

That observation became dual-channel learning: language becomes more tractable when another channel—images, code, data, action, or environment—constrains what matters. Language plus code and language plus data became especially important because the system could test meaning against types, values, operations, and outcomes.

That work led to an interpretable graph substrate for language, meaning, code, data, actions, and memory—and then to ProtoScript, the language for declaring and modifying it. The modern agent runtime is one practical part of that older project. It is why Buffaly does not only remember in text. It remembers in executable structure.

Read Goodnight Moon and the Long Road to Buffaly

Part 1