Reasoning Layer

Build trustworthy agents  

We are developing the neurosymbolic reasoning foundation for autonomous agents - a System 2 harness for thinking deliberately with System 1 models.

Demos
00 — The Problem

Why agents today
can't be trusted

LLM-based agents are powerful but fundamentally brittle — they hallucinate, resist steering, and offer no explanation for what they do. Deploying them in production means accepting opacity as a given. We don't.

Reliability

Unreliable by design

Transformer models generate the most probable next token — not the most accurate answer. Without grounding in explicit knowledge, agents hallucinate facts, fabricate reasoning chains, and confidently produce wrong results. There is no architectural guarantee of correctness.

Steerability

Hard to steer at runtime

Hardcoded orchestration workflows break the moment requirements shift. Meta-agent approaches pass intent through context windows — instructions that degrade, get ignored, or conflict. Neither model gives operators reliable, inspectable control over what the agent actually does.

Explainability

Unexplainable decisions

Attention weights are not a causal account of a decision. When an LLM-driven agent takes an action, there is no trace of why — only what. Debugging requires guesswork, alignment requires prompt tuning, and auditing is structurally impossible.

01 — Platform

The reasoning layer,
decomposed

We build the algorithmic foundation that sits between your large model and your agent's actions — giving it the ability to reason structurally, act safely, and explain itself clearly.

Knowledge Graph

An explicit and persistent representation of domain concepts, relations, and axioms — the structured knowledge foundation that powers reasoning, orchestration, and explainability across every agent session. Built from expert knowledge.

Concepts · Relations · Axioms
Reliable reasoning.

Neuro-Symbolic Primitives

Composable blocks that combine neural inference with logical reasoning. Agent reasons using rules with conditions and consequences — not just pattern-match on tokens.

Logic · Conditions · Consequences
Steerable operation.

Orchestration Directives

Declarative policies that govern how agents think, decide, and execute. Schemas aligned with a human expert's mental model — not imperative code that breaks at scale.

Policy · Schemas · Mental Models
Explainable Decisions.

Causal
Provenance

Every decision causally determined and traced. Audit any agent decision with a deterministic lineage of data and knowledge. Ensure agents do not take unauthorized action.

Causal · Lineage
02 — Process

From human expertise
to trusted autonomy

Use Polycog's software framework — cognition — to build your agent harness. Works with any model. Deploy it as you like - we are not a captive platform.

—01
Define the Knowledge Graph
Encode your knowledge — concepts, relations, and axioms drawn from experts as a persistent graph. This graph accumulates information over time and describes the state of the world and an agent's internal processing.
—02
Build Reasoning Primitives
Write neural and symbolic reasoning blocks that operate over the knowledge graph. Logical rules encode conditions and consequences, enabling the agent to reason deterministically.
—03
Design Orchestration Directives
Write orchestration directives in plain language declaratively using experts' mental models. Polycog enforces them programmatically at runtime — sequencing actions, calling tools, and resolving conflicts.
—04
Observe, Explain, Control
Every decision emits a structured causal trace. Query why any agent took any action, diff behavior across runs, and tighten alignment by updating the knowledge graph, reasoning primitives, or directives — no guesswork required.
03 — Principles

We believe agents
must earn trust

These aren't aspirational values — they're architectural constraints we've built into our stack. Trust is not a vibe; it's intentional design.

No black boxes.

Every decision an agent makes should be traceable to a cause. We build infrastructure that makes opacity structurally impossible, not just configurable.

Primitives, not monoliths.

We provide the smallest useful unit of reasoning. You compose. This gives you control over the entire reasoning stack without inheriting our assumptions about your domain.

Safety as structure.

Safety is not a feature you add later. Constraints are baked into the reasoning loop itself — before any action is taken, not as a post-hoc filter that can be bypassed.

Contact

Build agents you can trust

Let's team up to enable your cognitive agents.
Ping us and we'll reach out.