T2K Text2Knowledge

The semantic learning control plane

Make decisions that can learn without losing control.

T2K turns source-backed claims and operational facts into governed knowledge. It preserves the state, reasoning, authority, execution receipt, measured outcome, and policy version so every improvement can be inspected, evaluated, deployed, and rolled back.

Explore the closed loop Open decision learning
  • Live platform
  • Open runtime + local MCP + hosted APIs
  • Private by default

Facts need meaning. Decisions need context. Learning needs receipts.

Facts without an ontology are ambiguous. An ontology without facts cannot guide action. T2K joins both with an explicit objective and policies, then preserves the full episode instead of hiding it in a prompt.

The operating model

One equation. Four inputs. No hidden leap.

The same facts can lead to different choices when the objective or policy changes. T2K makes those differences visible and versioned.

Decision = Reasoning ( Ontology + Facts + Objective + Policies )
Stable model

Ontology

Defines entities, relationships, constraints, types, and reusable decision templates.

Changing state

Facts

Captures graph-local claims with source evidence, time, modality, confidence, and review state.

Desired outcome

Objective

States what the decision should optimize, including tradeoffs, alternatives, and uncertainty.

Permitted action

Policies

Applies laws, company rules, safety limits, authority, and required review before action.

The governed closed loop

Outcomes improve the next policy. They do not rewrite it.

T2K turns each consequential decision into a replayable episode. Candidate behavior is computed over disjoint held-out episodes, checked for action coverage and guardrails, then promoted by an independent human reviewer.

Outcome is not reward. Reward is a versioned evaluation. Feedback is not truth. Observations still need provenance and review. Learning is not mutation. New behavior is an immutable policy version.
Run the closed-loop tutorial
01StateOntology + accepted facts
02ReasonVersioned policy run
03AuthorizeNamed authority
04ExecuteAction + receipt
05ObserveSourced measurement
06EvaluateReward vector + attribution
07PromoteReplay + review + rollback

What Studio provides

Infrastructure for knowledge that has to hold up.

Ontology Studio is a managed multi-workspace semantic and decision control plane with seven deliberately separate planes. Signed cross-instance federation remains roadmap work.

01 / Definition

Version the language of the business.

Compile immutable ontology packs, dependencies, business contexts, canonical definitions, and reusable decision templates.

  • Semantic versions and compatibility diffs
  • Conformance checks and lifecycle review
  • Deterministic resolved pack sets
02 / Knowledge

Keep facts owned and evidenced.

Private graphs contain local entities, temporal claims, attestations, disputes, and provenance.

03 / Decision

Freeze context before acting.

Immutable snapshots preserve inputs, alternatives, recommendations, authority, actions, and outcomes.

04 / Execution

Prove what actually ran.

Track idempotent connector attempts, external transactions, receipts, reconciliation, and reversal.

05 / Observation

Measure without inventing causality.

Keep sourced observations, baselines, windows, units, and attribution confidence explicit.

06 / Learning

Improve through governed releases.

Evaluate reward vectors, replay candidates, activate one immutable policy version, monitor, and roll back.

07 / Exchange

Generalize without leaking.

Publish exact, redacted, or aggregate knowledge and promote reusable semantics through review.

The reusable framework boundary

Bring the semantics. Keep your runtime.

@t2kai/core gives agents and applications the same contracts Studio uses: ontology manifests, deterministic pack compilation, graph and claim records, Decision Contexts, episodes, policies, rewards, and a typed control-plane client. The runtime and ontology-pack standard are now public under Apache-2.0 with conformance fixtures, deterministic reward evaluation, a local Postgres lifecycle, a tested create-t2k scaffold, and the safe local @t2kai/mcp adapter. All three public packages have clean-install coverage and Node 20/22 CI.

3 public npm packages Node 20.10+ compiler target Deterministic semantic hashes
Build with T2K View the open source
agent-bootstrap.ts auditable input 
import { T2kClient } from "@t2kai/core";
import { compileOntologyPackSet }
  from "@t2kai/core/compiler";

const semantics = compileOntologyPackSet({
  manifests: [kernel, smb, vertical],
  roots: [{
    ontologyId: "field-service",
    version: "^1.0.0"
  }],
  contextValues: businessContext
});

if (semantics.status !== "valid") {
  throw semantics.diagnostics;
}
resolution sha256: reproducible behavior review before deploy

From source packet to a better next decision

Structure. Reason. Authorize. Measure. Improve.

T2K creates a chain of custody for meaning. Each step produces a reviewable object instead of silently rewriting the previous one.

  1. 01
    Ingest

    Keep the original document and its source metadata.

  2. 02
    Structure

    Map supported sources into proposed entities and claims against accepted definitions.

  3. 03
    Contextualize

    Bind facts, objective, policies, uncertainty, and freshness.

  4. 04
    Decide

    Separate recommendation from human authorization and action.

  5. 05
    Execute

    Require idempotency, rollback, and a receipt for external effects.

  6. 06
    Observe

    Measure declared outcomes without confusing sequence with causality.

  7. 07
    Learn

    Replay candidates and promote only reviewed policy or ontology versions.

Resolved pack set Accepted versions
Project packTransfer transition
Vertical packField service
Foundation packSMB operations
KernelT2K core
bound to
Private knowledge graph Company-owned
Customer claim Equipment claim Margin claim
Decision context What should happen next? Facts + objective + policies + authority

Three ways in

Useful to operators. Composable for developers.

For SMB teams

Turn operating memory into a system.

Capture what owners, employees, advisors, and records know. See unresolved risks, make repeatable decisions, and learn from measured results without giving up human authority.

Run the guided SMB tutorial
For developers

Build on contracts, not prompt conventions.

Use ontology manifests, canonical definition refs, graph ownership, rich claims, Decision Episodes, versioned policies, REST, TypeScript, and MCP.

Open the developer platform
For connected systems

Share semantics without sharing everything.

Keep customer identity and facts local. Exchange approved knowledge, return execution receipts and observations, then promote evaluated behavior or reusable definitions through separate review gates.

Inspect decision learning

A concrete implementation

TransferOS plugs into T2K. It does not collapse into it.

TransferOS uses the shared semantic infrastructure for business transitions while retaining its own workflows, records, and project ontology.

T2K owns
  • Domain-neutral ontology kernel
  • Pack compiler and registry
  • Graph and claim contracts
  • Decision and exchange controls
  • Episode, reward, and policy lifecycle
Compatible pack Private graph Controlled exchange Governed learning
TransferOS owns
  • Transition projects and participants
  • Diligence and handoff workflows
  • Business-specific facts
  • Product experience and automation
  • Vertical state, action, and reward semantics

Reusable SMB concepts can move upward only through evidence-backed promotion. Private company records never become universal entity IDs.

Ontology Studio is live

Learn the model, then inspect the whole loop.

Start with a plain-language walkthrough. Build one small workspace. Then govern packs in the semantic control room and inspect policy, episode, reward, and promotion state in Decision Learning.

Start learning Open decision learning
  1. 01
    Understand the modelOntology, facts, objectives, and policies
  2. 02
    Try a complete workflowTurn an SMB note into a cited risk view
  3. 03
    Choose your pathOperator, developer, or system integration
  4. 04
    Govern shared semanticsPacks, templates, promotion, and audit events
  5. 05
    Close the loopEpisodes, rewards, policy evaluation, deployment, and rollback

FAQ

What T2K is, and what it is not.

The boundaries matter as much as the capabilities.

What is Text2Knowledge?

A semantic control plane for turning source material into governed ontologies, evidenced claims, knowledge graphs, and reviewable decision contexts.

How is it different from a summary or chatbot?

A summary compresses evidence into prose. T2K keeps definitions, facts, sources, objectives, policies, recommendations, and decisions separate.

Can another product use T2K?

Yes. The Apache-2.0 standard, compiler, evaluator, client, safe local @t2kai/mcp adapter, and tested create-t2k scaffold are public in t2k-core. The @t2kai/core, @t2kai/mcp, and create-t2k packages are published on npm; core and create-t2k carry registry provenance. Approved integrations can also bind private graphs and use hosted REST or MCP operations without moving their runtime into Studio.

Is TransferOS part of the core ontology?

No. It is a project-specific system using the T2K kernel and layered SMB packs. Its private records remain graph-local.

Does T2K automatically make decisions?

No. It can assemble evidence and recommendations, but those remain separate from human authorization, action, rollback, and outcome tracking.

Is every feedback loop reinforcement learning?

No. T2K supports audit-only, supervised-feedback, contextual-bandit, sequential-RL, and optimization modes. Consequential SMB workflows start with supervised feedback and offline evaluation.

Does Studio understand any document automatically?

No. The built-in extractor is deterministic and template-oriented. External extractors can be tested in shadow mode, but general schema-guided LLM extraction remains roadmap work.

Is the current platform federated?

No. Studio provides controlled publication, lineage, redaction, and revocation inside one managed multi-workspace control plane. Signed cross-instance exchange and receiver-side acceptance are not yet implemented.

How can I try it?

The public guides require no account. Start with the 15-minute workspace guide or the closed-loop tutorial, then inspect semantic governance or live Decision Episodes.

Built for consequential knowledge

Text2Knowledge is the ontology and decision infrastructure layer from sig.ai, built on 25 years of work in NLP, machine learning, bioinformatics, healthcare, and applied data systems.

LLMs made language fluid. T2K makes the resulting knowledge explicit, governed, and usable by people and software that need more than a plausible answer.

Start with one decision

Make the path to action visible. Make improvement defensible.

Bring a source packet, a question, and the constraints that matter.

Explore the closed loop