Buffaly: High-trust agents with deterministic control

We use LLMs as assistants, not the control plane. Buffaly grounds outputs in ontology-backed policy graphs and produces auditable traces.

Buffaly is a technology stack developed by IntelligenceFactory.ai. We open source the base components: ontology storage, ProtoScript language, deterministic NLU, and graph learning. If you are interested in deploying an agent utilizing Buffaly in high trust / low error environments, contact us for an engagement.

LLMs Under Control

LLMs are useful for language tasks, but they are not trustworthy as the control plane for high-consequence workflows. Buffaly is the control layer: it constrains model-assisted outputs to typed contracts, validates them against an ontology-backed policy graph, and emits an auditable trace that operators can review.

How Buffaly grounds and validates

Buffaly uses structured ontologies (ICD-10, SNOMED-CT, custom domain ontologies) as the source of truth for interpretation and action. LLMs may assist with language normalization or proposal generation, but Buffaly performs validation and policy enforcement against ontology-backed constraints and produces an auditable reasoning trace.

How Buffaly is used in production

• Deployed inside your VPC or on-prem where required.
• Explicit tool boundaries and approval gates for any side effects.
• Deterministic policy and ontology resolution for compliance-critical decisions.
• Evidence by design: every decision and action produces a trace suitable for audit.

The Two Pillars of Buffaly

Buffaly treats "what the agent knows" and "what the agent can do" as versioned code, avoiding the unpredictability of ephemeral prompts.

Typed Contracts > Prompt Glue

Buffaly enforces correctness at the runtime level. We don't negotiate correct behavior in a system prompt; we enforce it via ProtoScript typed signatures, ensuring auditable, constrained actions.

// Prone to unconstrained generation
{
  "name": "update_directory",
  "description": "Runs a script.",
  "parameters": {
    "type": "object",
    "properties": {
      "target_path": { "type": "string" }
    }
  }
}

// Strict, safe, and bound to Ontology
[SemanticProgram.InfinitivePhrase("to build a visual studio solution from a build profile")]
prototype ToBuildVisualStudioSolutionFromBuildProfile : OpsAction
{
    function Execute(BuildProfile buildProfile) : string
    {
        if (buildProfile?.Solution == null)
            return "Invalid BuildProfile: Solution is required.";

        string buildOutput = VsProjects.BuildSolution(...);
        string output = ToTruncatedText(buildOutput, 4000);
        return "Build Solution: " + buildProfile.Solution.SolutionName;
    }
}

Auditability & Full Execution Tracing

"Explainable AI" usually means asking the model to guess why it did something post-hoc. Buffaly doesn't guess. It produces a deterministic execution trace of every action, parameter, and referenced prototype. You gain complete observability grounded in execution artifacts, not narrative.

Discuss a high-trust agent deployment

Include your industry, compliance constraints, deployment environment (VPC/on-prem), and the workflows you want the agent to run. We will respond with next steps and a proposed technical path.