Long-form on agent SDK design.
Memory, Plan Mode, consent, on-prem deployment, vertical patterns — and honest comparisons against the alternatives. No vendor copy. Citable code, real architectures, the trade-offs we hit.
Thinking
Foundational pieces on what agent memory is, what Plan Mode is, and why open-weight defaults matter.
Why Agent Memory Is Broken (And the Path to Fix It)
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
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
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
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
The autonomous-loop architecture conflates two responsibilities: deciding and doing. Splitting them — agent stateless, human stateful — fixes more than it complicates.
Comparison
How ONTO stacks up against the other agent SDKs and memory layers. Updated when they release.
Agent SDK Comparison: ONTO vs Claude vs OpenAI vs Google ADK (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
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
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
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
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
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
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.
Industry
Vertical guides: healthcare, financial services, legal, support, personal AI, research, HR.
Building HIPAA-Ready AI Agents: A Compliance Engineer's Checklist
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
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
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
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
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
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
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.
Engineering
How-to and architecture — on-prem deployment, multi-tenant memory, cost observability, tutorials.
On-Premise AI Agents: How to Run Without Sending Data to OpenAI
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
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
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
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
Install ONTO, run your first agent, extract typed facts, plan an action, and execute it under consent scopes. No API key required.