Buffaly is an open-source runtime you install on your own machines. It gives LLMs typed memory, real tools, and the ability to turn completed work into software you keep—so the models stay replaceable and the intelligence stays yours.
The durable layer
Models will improve. Prices will change. Providers will come and go. The workflows, tools, history, and judgment your organization develops should not disappear every time you switch a model.
Buffaly sits between replaceable models and your business. The labs provide reasoning. You keep the intelligence that reasoning creates.
What stays when models change
Your ontology, built tools, policies, history, and generated code live in Buffaly. Model access is a replaceable service.
You keep
You rent
Token-in, token-out reasoning
Why I released Buffaly
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.
Do not take our word for it
Install Buffaly on infrastructure you control and connect the models you choose.
Inspect the ontology, typed actions, generated tools, and execution paths behind its answers.
Build something difficult. Keep what works. Find the limits without waiting for a vendor’s permission.
Memory you can read
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
prototype ClaimsDenialAppeal : OperationalCapability
{
EntityName = "prepare a denial appeal";
DependsOn = EligibilityEvidence;
Produces = AppealPacket;
}
prototype ToPrepareDenialAppeal : TypedAction
{
Input = DeniedClaim;
Output = AppealPacket;
RequiresApproval = true;
}Five mechanisms, not five slogans
Each mechanism takes work that prompt-driven agents perform in text and moves it into inspectable runtime structure your organization can keep.
Buffaly promotes language into typed entities it can query, reuse, and refine.
What it learns about customers, systems, policies, tools, and exceptions becomes a working model of your organization—not another transcript the next agent must reinterpret.
Successful repeated reasoning can become a typed action or deterministic implementation.
The tenth occurrence of a workflow can use software instead of asking the model to rediscover the procedure. The capability remains available to every future agent.
The agent selects a typed action; the runtime calls the real implementation.
No MCP server, CLI wrapper, or hand-built JSON adapter is required when a native boundary already exists.
Buffaly can bind directly to C# methods, .NET objects, DLLs, ProtoScript, databases, files, APIs, and internal services. Your business logic stays native; you do not rebuild your company as AI connectors.
The model can reason over a typed reference without receiving the underlying value.
PHI, credentials, financial records, private objects, and operational state can stay inside the runtime and your native systems. The model chooses the action; trusted code holds the data.
Repeated reasoning becomes a tool. Repeated tools become native execution.
You buy the reasoning once and keep the result instead of renting the same reasoning by the token forever.
See the measured 79.7% reductionBuilt for high-trust work
In healthcare, finance, infrastructure, and other high-consequence operations, a model cannot be the data store, policy engine, and execution environment. Buffaly keeps those responsibilities in a runtime you control.
The model can interpret intent and handle ambiguity. Reviewed software still decides what is allowed, touches the real systems, and records what happened.
The agent chooses a typed path. Strict, reviewed code performs the operation and validates its result.
PHI, credentials, and private records can stay behind runtime handles instead of entering model context.
Actions, inputs, decisions, and outcomes produce an execution trace for operational and regulatory review.
Rules are represented in system contracts, ontologies, schemas, and native business logic—not left for a chatbot to improvise.
The origin story
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 BuffalyPart 1
Why Buffaly is a real alternative to scaling prompt loops forever.
Read the essayPart 2
How Buffaly agents remember in code, bind native actions, and accumulate executable structure.
Read the architecturePart 3
The long road from children’s language learning to ontology, ProtoScript, and Buffaly.
Read the origin storyChoose your path
Run Buffaly yourself, inspect the code, connect your providers, and build your first capability.
Run Buffaly in an environment you control, with your own data boundaries, applications, and deployment policies.
Explore deployment optionsBring one difficult workflow. Intelligence Factory can deploy, integrate, and operate Buffaly with you.
Discuss a workflow