# ONTO

> The open-source agent SDK where humans drive the state. Python, TypeScript, and Rust SDKs over one Rust core. Typed memory (UPO + SMO), Plan Mode, per-call consent scopes, and open-weight defaults. MIT or Apache-2.0.

ONTO inverts the standard agent loop. The agent reads state and proposes actions; the human writes state and approves. Three runtime primitives enforce the split: UPO writes are explicit, Policy Guard gates every tool call against per-call consent scopes, and Plan Mode halts before execution so humans can review proposed actions before any side effects.

Defaults to Ollama Cloud (free open-weight). Swap to Anthropic or OpenAI with one env var. On-prem path uses Sled or Postgres + pgvector, fastembed local embeddings, Helm recipes.

Pre-1.0 (current 0.1.0). 238 tests across the stack. Phases 0–20 shipped.

## Core pages

- [Home](https://onto.neullabs.com/): the value proposition, code tabs, comparison teaser.
- [Features](https://onto.neullabs.com/features): Plan Mode, typed memory (UPO + SMO), four-level extraction, Policy Guard, async writes, cost meter, eval framework, polyglot SDKs, MCP + Claude Skills.
- [Architecture](https://onto.neullabs.com/architecture): how a request flows — agent proposes, Policy Guard checks scopes, Plan Mode halts, human approves, execute + write UPO. Four layers over one Rust core.
- [Quickstart](https://onto.neullabs.com/quickstart): install (pip/npm/cargo), point at a model, run with consent scopes, review a plan and approve. Python + TypeScript examples.
- [Comparison](https://onto.neullabs.com/comparison): ONTO vs Claude Agent SDK, OpenAI Agents SDK, Google ADK, LangChain. Honest matrix and FAQs.
- [Docs](https://onto.neullabs.com/docs): install, quickstart, and links to the full canonical documentation.
- [FAQ](https://onto.neullabs.com/faq): about ONTO, choosing it vs alternatives, memory/consent/Plan Mode, deployment and operations.
- [Glossary](https://onto.neullabs.com/glossary): UPO, SMO, Plan Mode, Policy Guard, consent scope, four-level extraction, cost meter, MCP, Rust core — defined.

## Industries

- [Healthcare](https://onto.neullabs.com/industries/healthcare): HIPAA-aligned audit trail, role-based consent scopes, Plan Mode before any clinical order, on-prem deployment.
- [Customer support](https://onto.neullabs.com/industries/customer-support): per-account durable memory, tier-based auto-approval, multi-tenant scoping, per-tenant cost meter.
- [Personal AI](https://onto.neullabs.com/industries/personal): durable user memory, async writes, background summarization, open-weight defaults.
- [Research](https://onto.neullabs.com/industries/research): four-level extraction at domain scope, conflict detection, Plan Mode synthesis, per-researcher cost rollups.

## Articles

- [Why Agent Memory Is Broken (And the Path to Fix It)](https://onto.neullabs.com/blog/why-agent-memory-is-broken): The standard agent loop has no idea who you are between sessions. Conversation buffers forget, embeddings retrieve the similar but not the true. Here is what typed memory looks like instead.
- [Plan Mode: Approving What Your AI Agent Does Before It Does It](https://onto.neullabs.com/blog/plan-mode-explained): How a first-class Plan Mode in your agent SDK turns hallucinated side effects into reviewable tasks — and why this is different from human-in-the-loop bolted on after the fact.
- [Typed Memory vs Vector Embeddings for AI Agents](https://onto.neullabs.com/blog/typed-memory-vs-embeddings): Why storing 'Alice is in UTC' as an embedding and retrieving it later by cosine similarity is the wrong primitive — and what to use instead.
- [The Case for Open-Weight Defaults in Agent Frameworks](https://onto.neullabs.com/blog/open-weight-defaults): Why an agent SDK that defaults to a proprietary hosted model — and treats open-weight as the fallback — pushes its users into vendor lock-in and gives them no on-prem path.
- [Stateless Agents, Stateful Humans: A New Architecture for AI Agents](https://onto.neullabs.com/blog/stateless-agents-stateful-humans): The autonomous-loop architecture conflates two responsibilities: deciding and doing. Splitting them — agent stateless, human stateful — fixes more than it complicates.
- [Agent SDK Comparison: ONTO vs Claude vs OpenAI vs Google ADK (2026)](https://onto.neullabs.com/blog/agent-sdk-comparison-2026): An honest head-to-head of the four major agent SDKs — where each wins, where each loses, and how to pick the right one for your project.
- [ONTO vs LangChain: When Typed Memory Beats Chains](https://onto.neullabs.com/blog/onto-vs-langchain): LangChain is the largest agent orchestration ecosystem in the world. So why pick ONTO instead? A direct comparison on memory, planning, consent, and operational concerns.
- [ONTO vs LlamaIndex: Agents vs RAG, Explained](https://onto.neullabs.com/blog/onto-vs-llamaindex): LlamaIndex is the most popular RAG framework. ONTO is an agent SDK. They solve adjacent problems — but treating them as substitutes leads to bad architecture. Here's how to pick.
- [ONTO vs Mem0: Choosing a Memory Layer for AI Agents](https://onto.neullabs.com/blog/onto-vs-mem0): Mem0 is a popular dedicated memory layer for LLMs. ONTO is an agent SDK with memory built in. What's the difference, and which one is right for your project?
- [ONTO vs Letta (MemGPT): Two Approaches to Long-Term Agent Memory](https://onto.neullabs.com/blog/onto-vs-letta): Letta (formerly MemGPT) pioneered the idea of agents managing their own memory through tool calls. ONTO takes a typed-graph approach. Same problem, different solutions.
- [ONTO vs CrewAI: Multi-Agent Without the Black Box](https://onto.neullabs.com/blog/onto-vs-crewai): CrewAI made multi-agent orchestration accessible. ONTO takes a different shape — subagents under explicit consent scopes, a depth budget, and rolled-up cost. Which fits your problem?
- [ONTO vs AutoGen: Human-in-the-Loop, Done Right](https://onto.neullabs.com/blog/onto-vs-autogen): AutoGen pioneered conversational multi-agent and human-in-the-loop patterns. ONTO takes a different approach to the same problem — Plan Mode as a runtime invariant. Here's how they compare.
- [Building HIPAA-Ready AI Agents: A Compliance Engineer's Checklist](https://onto.neullabs.com/blog/hipaa-ready-ai-agents): A practical checklist for taking an AI agent into a HIPAA-covered environment — what to log, what to tag, what to gate, and what to deploy on-prem.
- [Financial Services AI Agents: Audit Trails That Pass SOC 2 and FINRA](https://onto.neullabs.com/blog/financial-services-ai-agents): Financial services AI deployment is harder than healthcare in some ways and easier in others. A practical guide to the SOC 2, FINRA, and GDPR controls your agent system has to satisfy.
- [Legal AI Agents Without the Confidentiality Headache](https://onto.neullabs.com/blog/legal-ai-agents): Privilege, confidentiality, conflicts checking, and the unauthorized practice of law — what your legal AI agent actually has to handle, and how to handle it cleanly.
- [AI Customer Support That Doesn't Hallucinate Refunds](https://onto.neullabs.com/blog/customer-support-no-hallucinated-refunds): How to ship a customer support agent that remembers each customer, proposes refunds and escalations through Plan Mode, and auto-approves only when policy says so.
- [Building a Personal AI Assistant That Actually Remembers You](https://onto.neullabs.com/blog/personal-ai-that-remembers): Long-running personal AI fails on memory more than anything else. Here's an architecture for an assistant that learns who you are across sessions, with the user's facts staying on the user's side.
- [Research Agents: Mining Typed Facts from a Stack of Papers](https://onto.neullabs.com/blog/research-agents-typed-claims): A research copilot that pulls top-k chunks is fine. One that extracts typed claims with provenance, detects cross-paper conflicts, and asks before resolving them is better.
- [HR & Recruiting AI Agents That Stay GDPR-Compliant](https://onto.neullabs.com/blog/hr-ai-gdpr): AI in recruiting and HR has specific failure modes — bias, automated decisions on candidates, retention of personal data. Here's how to ship an HR agent that doesn't trip Article 22, 5, or 6.
- [On-Premise AI Agents: How to Run Without Sending Data to OpenAI](https://onto.neullabs.com/blog/on-premise-ai-agents): A practical guide to running production AI agents fully on your infrastructure — local models, local storage, local embeddings, Helm charts. No third-party API calls.
- [Multi-Tenant Memory: Scoping AI Agents for SaaS](https://onto.neullabs.com/blog/multi-tenant-agent-memory): If you're running an agent SDK in a multi-tenant SaaS, memory leakage between tenants is the bug that ends your company. Here's the architecture that prevents it structurally.
- [Cost Observability for AI Agents: Per-User, Per-Tenant Billing](https://onto.neullabs.com/blog/cost-observability-ai-agents): The OpenAI bill arrives. You can't tell which customer or which workflow drove it. Here's how to instrument AI agents so cost attribution is built in — not reverse-engineered from logs.
- [Ontology Extraction Explained: The Four Levels Every Agent SDK Should Have](https://onto.neullabs.com/blog/ontology-extraction-four-levels): Pulling typed facts from natural language is half the problem. The other half is knowing which level the fact lives at. Here's the four-level model and why every agent SDK should have one.
- [Getting Started with ONTO in Python: A 10-Minute Tutorial](https://onto.neullabs.com/blog/python-quickstart): Install ONTO, run your first agent, extract typed facts, plan an action, and execute it under consent scopes. No API key required.

## Reference

- [GitHub](https://github.com/onto-framework/onto-framework) — MIT or Apache-2.0 source
- [Canonical docs](https://onto-framework.github.io/onto-framework) — concepts, SDK, server, models
- [PyPI · onto-core](https://pypi.org/project/onto-core/)
- [npm · @onto/core](https://www.npmjs.com/package/@onto/core)
- [crates.io · onto-runtime](https://crates.io/crates/onto-runtime)
- [Full-text dump for LLM ingestion](https://onto.neullabs.com/llms-full.txt)
- [RSS](https://onto.neullabs.com/rss.xml)