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

Build with Buffaly

Add an AI assistant to your website or portal.

Let visitors and employees use your application through conversation. Connect your APIs, keep your existing permissions, choose your models, and let Buffaly learn over time.

See how website chat works

Public chat for sales

Illustrative public website chat using a public API, with the sales team watching and able to take over.

Private chat for your portal

Illustrative private portal chat working as the signed-in user with that person's existing permissions.

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 stores knowledge and executable behavior in the same ontology. Entities, relationships, functions, and actions form a runtime the agent can inspect, extend, and use. Successful work can become structured knowledge or callable code, instead of another procedure to reconstruct from a transcript.

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.

Memory in Buffaly has identity, types, relationships, and behavior. The agent can begin with partial knowledge and refine it as work reveals more about the objects, systems, and procedures involved.

Semantic bindings connect a request to specific entities and actions. Functions are first-class members of the ontology, so remembered knowledge and the operations that use it belong to the same executable graph.

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.

When a required capability is missing, Buffaly can write its implementation in ProtoScript or .NET, make it available to the running agent, and use it during the same work.

It can also convert successful procedures into reusable executable actions. The new capability becomes part of the graph the agent searches and executes, with typed inputs, outputs, and semantic bindings.

Supervision and learning alongside the main agent

Specialized companion agents support the primary session. System 2 supervises ongoing work, the online memory critic forms and refines structured knowledge, and the online action critic creates or improves reusable executable actions. Their observations and changes remain available for inspection.

Generated runtime capability

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

See Buffaly create and use a missing tool

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.

Operations can pass native results directly to one another, so a multi-step procedure does not require the model to carry every intermediate value through its context.

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.

As useful procedures become executable code, later runs can avoid repeated planning and per-record model calls. Buffaly retains the capability while reducing the generative work needed to use it.

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

Platform and integrations

A full agent platform beyond text-based orchestration.

Buffaly connects its executable ontology to communication, documents, development tools, cloud infrastructure, and data systems. Skills combine integrations, typed actions, prompts, and native implementations in the same runtime. Existing software can be attached directly, and missing capabilities can be created as the work requires.

Communication and documents

Work with Gmail, Drive, Docs, Sheets, and Calendar through Google Workspace integrations, with accounts and operations connected to the agent’s runtime.

Development and infrastructure

Use GitHub, local development tools, and AWS integrations for repository work, implementation tasks, and infrastructure operations.

Data and native software

Query SQL Server, work with local files, and call existing .NET code. Native objects and results can pass between actions without being flattened into model context.

Browser and desktop

Use browser and desktop capabilities when work requires a user interface, alongside API integrations and native execution.

Browse skills and integrations Build and attach capabilities

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