v1.1.3 • Node.js 22.13+ or 24+

One TypeScript Library for AI Agents, Complete Agent Runtimes Realtime Voice Every Modality Distributed Execution

Connector-first agents plus one observable runtime for complete OneRingAI and Codex SDK agent systems, distributed execution, realtime voice, and every model modality.


                                            npm i @everworker/oneringai

Read the User Guide

View on GitHub

Observable Agent Runtime

Connector-first native Agents

Portable, trusted execution

RUNTIME

Complete agent systems

One API for native OneRingAI and Codex SDK sessions, runs, live events, policy, workspaces, and normalized results.

REALTIME

Live voice agents

OpenAI Realtime and xAI Voice Agent with provider-specific session types, WebSocket, WebRTC credentials, tools, correct VAD, and SIP control.

DISTRIBUTED

Portable native Agents

Data-only packages, trusted-host hydration, local and remote tools, implementation fingerprints, and host-owned authority.

MODELS

Current vendor APIs

GPT-5.6, Claude 5, Gemini 3.7, Grok 4.6, DeepSeek V4, and lifecycle-aware aliases.

Releases 1.1.0–1.1.3

What’s new in OneRingAI 1.1

A vendor-neutral execution layer, portable native Agents, Agent-aware Realtime, and safer long-lived sessions—without changing the connector-first Agent path.

Vendor-neutral Agent Runtime

Run native OneRingAI and Codex SDK agent systems through immutable specs, sessions, observable runs, capability preflight, explicit policy, workspaces, cancellation, and normalized results.

Portable distributed Agents

Export a resolved native Agent as data, hydrate it on a trusted desktop host, place tools locally or remotely, and verify executable compatibility with protocol-v2 fingerprints.

Agent-aware Realtime

OpenAIRealtimeAgentSession refreshes managed context per turn and executes local tools through the Agent’s normal hooks, approval, permission, timeout, event, and metrics path.

Long-lived session rollover

agent.rolloverContext() creates a continuity brief at provider-session boundaries while preserving recent turns, complete tool pairs, plugin state, persistence, and the history journal.

Host-owned security

Portable package data never grants authority. Receiving hosts resolve connectors, identity, permissions, plugins, local implementations, provider policy, and every remote request from trusted state.

Current models and credentials

Registry v2 now covers 95 text/realtime models plus dedicated media registries. Runtime-only rotating OpenAI credentials support short-lived host keys across text and media requests.

Read the User Guide Read the model audit View the changelog

New execution layer in 1.1

Run complete agents through one observable runtime

The Agent Runtime does not replace Agent.create() or rebuild native agent loops. It gives applications one lifecycle for configuring, running, observing, cancelling, and collecting results from complete OneRingAI and Codex SDK agents.

Native loops stay nativeDrivers adapt complete agent systems while preserving each system’s own execution loop and tool semantics.

Live event journalObserve messages, reasoning, plans, commands, file changes, usage, and terminal state with bounded replay.

Fail-closed capabilitiesModel, reasoning, structured output, images, workspace access, and policy are checked before native work starts.

Portable executionMove native Agents across trusted hosts and bridge browser-safe Realtime media without moving credentials or authority.

Read the Runtime guide Run the example

ONE OBSERVABLE RUN @everworker/oneringai/agent-runtime

const codingAgent = runtime.agent({
  id: 'coding-agent',
  driver: 'openai.codex.sdk',
  connector: 'openai-main',
  model: 'gpt-5.6-terra',
  reasoning: { effort: 'high' },
});

const session = await codingAgent
  .openSession({
  context: { userId },
  policy,
  observation: {
    mode: 'live',
    detail: 'reasoning',
  },
});

const run = await session.run(task);
for await (const event of run.events()) {
  render(event);
}

const result = await run.result;

immutable spec

session + run

events + result

oneringai.agent openai.codex.sdk local backend capability preflight

A first-class subsystem

Memory that understands relationships, not just messages

OneRingAI includes a standalone entity-and-fact memory system with graph traversal, vector embeddings, ranked recall, document search, signal ingestion, evolving profiles, and production-grade permissions.

Graph-native knowledgePeople, organizations, tasks, events, documents, and typed relationships with provenance.

Vector + ranked retrievalSemantic search, N-hop traversal, confidence, recency, importance, and as-of queries.

Learns from signalsTurn text, email, calendars, or conversations into resolved entities, facts, and profiles.

Standalone or agent-readyUse MemorySystem directly or add safe read/write tools and context injection to any agent.

Explore the memory system API reference

KNOWLEDGE GRAPH entities · facts · embeddings

memory_search({ query: "What matters for the launch?" }) → ranked facts + related entities

Mongo + Atlas bitemporal principal ACLs 6 read + 6 write tools

Built with OneRingAI

Meet AMOS, your terminal AI agent

AMOS is the working CLI application inside the OneRingAI repository. It shows how connectors, agents, tools, permissions, context, and persistence fit together in a useful product—not just an isolated snippet.

Switch providers liveChange connector, vendor, or model without rewriting agent logic.

Code with guardrailsUse filesystem and shell tools with explicit execution permissions.

Research the webSearch through Serper and scrape pages through ZenRows connectors.

Keep your placeInspect context usage, then save and resume working sessions.

Read the AMOS guide Browse the source

amos — terminal agent

$ cd apps/amos

$ npm run dev

AMOS ready · connector: openai-main

› /prompt use coding-agent

Prompt switched to coding-agent

› /external setup search

Serper search connected

› /context budget

Context healthy · tools ready

› /session save launch-research

Session saved

AMOS running in a terminal with the OpenAI connector and coding-agent prompt — AMOS running from `apps/amos` with an OpenAI connector. Open the screenshot to view it full size.

50 authentication templates, generic authenticated API access for every configured service, and specialized tool bundles for selected connectors

Google

GitHub

Discord

Stripe

Notion

HubSpot

Jira

Shopify

Dropbox

GitLab

Mailchimp

PayPal

Airtable

Sentry

Confluence

Intercom

Linear

Datadog

Asana

Trello

Bitbucket

QuickBooks

Zendesk

PagerDuty

Box

Brave

Google Cloud

Google Drive

RapidAPI

OneRingAI Feature Highlights

Production AI agents, complete runtimes, every modality

Node.js 22.13+ or 24+, strict TypeScript, connector-first authentication, unified inference APIs, portable execution, and production agent infrastructure in one package.

Current multi-vendor APIs

OpenAI, Anthropic, Google, xAI, and more across text, image, video, embeddings, TTS, STT, and realtime voice—with one coherent API.

Plugin-first context and memory

Feature-flagged plugins assemble instructions, state, tools, persisted stores, compaction, and self-learning graph memory into one token-budgeted context. Context guide

Connectors for every system

Start from 50 authentication templates. Every configured service gets generic authenticated API access; selected services add specialized tool bundles. Connector catalog

Tools, permissions, and orchestration

Start with 39 connector-free tools in eight categories, then add connector, context-plugin, memory, orchestrator, and MCP tools dynamically. Tool catalog

Observable Agent Runtime

Run complete native OneRingAI or Codex SDK agents through shared specs, sessions, live event journals, policy, capability checks, cancellation, and normalized results. Runtime guide

Enterprise grade quality you can trust

The library is the core of Everworker.ai enterprise agentic platform, so is battle proven in its quality and resilience.

OneRingAI vs LangChain vs CrewAI

Wondering which library to choose? OneRingAI is lighter, fuller, straightforward and 100% typescript nodejs.

Read In-Depth Comparison!

Comparison

OneRingAI vs LangChain vs CrewAI vs OpenClaw

Feature Comparison — reviewed August 2026

OneRingAI is a unified TypeScript agent library (~165K source LOC, 23 direct runtime dependencies) with a connector-first native Agent path and an optional runtime for complete agent systems. Authentication, security, resilience, observability, multimodal inference, and distributed execution are first-class library concerns.

About OpenClaw: OpenClaw (~355K GitHub stars) is a self-hosted personal AI assistant platform for messaging channels (WhatsApp, Slack, Telegram, etc.), not a developer SDK. It is included here for architectural comparison, but serves a fundamentally different use case.

1. Architecture Philosophy

Feature	OneRingAI	LangChain / LangGraph	CrewAI	OpenClaw
Core paradigm	Connector-first (auth registry → agent → provider)	Runnable composition (LCEL) → Graph nodes	Role-based agent crews + event-driven flows	Gateway → channels → skills
Language	TypeScript (strict)	TypeScript (primary), Python (separate repo)	Python only	TypeScript
LOC / Deps	~165K source LOC / 23 direct runtime deps	~200K+ LOC / 15+ packages	~100K LOC / 33 deps	~300K+ LOC / extensions
Type	Developer SDK / library	Developer SDK / framework	Developer framework	Self-hosted product
Setup surface	`Agent.create()` for native Agents; `AgentRuntime` for complete agent systems	Models, agents, middleware, tools, and LangGraph primitives	Role/goal/backstory agents, tasks, crews, and flows	Install, configure channels, and run
Complete-agent runtime	Vendor-neutral specs, sessions, live event journal, capability preflight, policy, workspaces, cancellation, and normalized results for native OneRingAI and Codex SDK drivers	LangGraph runtime and deployment surfaces	Crew and Flow execution	Product-owned agent runtime

OneRingAI's advantage: A compact, single-package TypeScript surface keeps the common path at Connector → Agent → Provider. Runtime performance depends on the workload and provider, so benchmark your own use case rather than relying on framework-wide percentage claims.

2. Multi-Vendor LLM Support

Feature	OneRingAI	LangChain / LangGraph	CrewAI	OpenClaw
Vendors	12 native (OpenAI, Anthropic, Google, Vertex, Groq, Together, Perplexity, Grok, DeepSeek, Mistral, Ollama, Custom)	36+ via dedicated @langchain/* packages	6 native + LiteLLM fallback for 20+	30+ via extensions
Model registry	Registry schema v2: 95 text/realtime records with lifecycle, aliases, endpoints, official sources, pricing, and capability metadata	No centralized registry	100+ models mapped for context windows	No registry
Cost calculation	calculateCost(model, in, out) → exact USD	Third-party (LangSmith)	No built-in	No built-in
Multi-key per vendor	Named connectors: openai-main, openai-backup	Not native	Not native	Auth profile rotation with failover
Vendor switching	Change `connector` and `model`; prompts, tools, memory, and agent logic stay unchanged	Change model integration and provider-specific config	Change LLM/model config	Change extension config
Thinking / reasoning	Vendor-agnostic config — maps to Anthropic budgets, OpenAI effort, Google thinkingLevel	Per-provider configuration	No unified abstraction	Per-provider

Why OneRingAI wins: Native vendor support with typed model registry and built-in cost tracking. Named connectors allow multi-key setups (prod/backup/dev). Vendor-agnostic thinking/reasoning config — write once, run on any provider.

3. Authentication & Connector System

Feature	OneRingAI	LangChain / LangGraph	CrewAI	OpenClaw
Auth model	Centralized Connector registry (single source of truth)	Credentials configured per model or tool integration; no shared connector registry equivalent	Credentials configured per model or tool integration, commonly through environment or config	Auth profiles per extension
OAuth 2.0	Built-in OAuth flows, AES-256-GCM encrypted storage, refresh-strategy enforcement, and 50 vendor templates	No framework-level multi-service OAuth registry	No framework-level multi-service OAuth registry	Extension-specific authentication
Multi-user isolation	userId + accountId scoping, connector allowlist per agent	Implemented by the host application	Managed team controls in CrewAI Enterprise; application scoping remains host-defined in OSS	Designed around a single-user trust boundary
External API tools	`ConnectorTools.for('work-github')` adds generic authenticated API access plus GitHub's specialized bundle. The catalog covers 50 auth templates, selected specialized bundles, and custom services.	Community tool packages	Via Composio (external)	5,400+ skills on ClawHub

OneRingAI's advantage: The Connector API combines provider credentials, multi-service OAuth, encrypted storage, multi-user scoping, and per-connector resilience behind one typed registry. Other frameworks generally configure credentials at the model, tool, extension, or host-application layer.

4. Security & Permissions

Feature	OneRingAI	LangChain / LangGraph	CrewAI	OpenClaw
Permission system	3-tier: user rules → delegation hierarchy → 8-policy chain	Guardrails and middleware; no equivalent 3-tier permission-policy manager	Task guardrails and human feedback; RBAC is part of CrewAI Enterprise	Tool policy pipeline with exec approvals
Tool-level scoping	Per-tool: always / session / once / never	Human-in-the-loop middleware can gate selected tools	Human feedback can gate workflow steps	Exec approval per command
Built-in policies	Allowlist, Blocklist, RateLimit, PathRestriction, BashFilter, SessionApproval, Role, UrlAllowlist	PII detection, human-in-the-loop, model/tool call limits, and custom middleware	Task guardrails, callbacks, and human feedback	Tool allow/deny policy, sandboxing, and exec approvals
Circuit breakers	Per-tool + per-provider (configurable thresholds)	None	None	None
Audit trail	Event-based: permission:allow, permission:deny, permission:audit	LangSmith tracing or custom logging middleware	Event listeners in OSS; managed traces in CrewAI Enterprise	Mutation tracking and approval events

OneRingAI's advantage: Its security controls are packaged as a cohesive library layer: 3-tier permission evaluation, 8 policy types, per-tool circuit breakers, rate limiting, and bash filtering. LangChain, CrewAI, and OpenClaw also provide guardrails or approval controls, but with different scopes and deployment models.

5. Context Management

Feature	OneRingAI	LangChain / LangGraph	CrewAI	OpenClaw
Architecture	Plugin-first AgentContextNextGen with working/in-context state, self-learning memory, background ingestion, tool catalog, and shared workspaces	Short-term (state) + Long-term (Store API) + Legacy (Buffer/Summary)	Unified Memory with scoped storage + Knowledge (RAG)	Plugin-based context engine
Compaction	Algorithmic (75% threshold), tool pairs removed together, pluggable strategies	Message filtering / summarization	Auto-summarization at token limits	Built-in compaction
Token budgeting	Per-plugin token tracking with detailed ContextBudget breakdown	No native budget API	Context window management (85% safety ratio)	Provider-based
In-Context Memory	Data stored DIRECTLY in prompt — LLM sees values immediately, priority-based eviction	Not available	Not available	Not available
Long-term memory	Entity/fact memory graph with semantic search, profiles, behavior rules, permissions, and optional background extraction	Store API (namespace-based, cross-session)	Deep recall with LLM analysis, composite scoring	Wiki + knowledge plugins
Context plugins	Feature-flagged built-ins + custom IContextPluginNextGen and IStoreHandler APIs	No plugin system	Not extensible	Extensible via plugins

OneRingAI's advantage: Its plugin-based context system keeps frequently accessed InContextMemory directly in the prompt, with per-plugin token budgets for an exact breakdown. Custom plugins and store handlers use the same lifecycle.

6. Tool System

Feature	OneRingAI	LangChain / LangGraph	CrewAI	OpenClaw
Built-in tools	39 connector-free generated tools across 8 categories. Connector, context-plugin, memory, orchestrator, and MCP tools are discovered dynamically.	50+ via integrations	70+ via crewai-tools	60 bundled + 5,400 on ClawHub
Per-tool circuit breakers	Yes — independent failure protection per tool	No	No	No
Permission system	3-tier policy chain with 8 policies	No built-in	No built-in	Exec approval pipeline
Desktop automation	11 tools (screenshot, mouse, keyboard, window) with multimodal images	Not built-in	Not built-in	Not built-in
Custom tools	Meta-tools: agent creates its own tools at runtime (save, load, draft, test)	tool() function + Zod schema	BaseTool class or @tool decorator	Skills + plugins
Tool metrics	Usage count, latency, success rate — no SaaS required	LangSmith tracing has a free developer allocation and paid higher-volume tiers	Managed observability is available in CrewAI Enterprise	Local logs and events

Why OneRingAI wins: Per-tool circuit breakers mean one flaky API doesn't take down your agent. Desktop automation (computer use) is built-in. Meta-tools let agents create their own tools at runtime.

7. Multi-Agent Orchestration

Feature	OneRingAI	LangChain / LangGraph	CrewAI	OpenClaw
Orchestration model	createOrchestrator() with 3 routing modes: DIRECT / DELEGATE / ORCHESTRATE	LangGraph: stateful graphs with conditional edges	Crew (sequential/hierarchical) + Flow (event-driven DAGs)	Subagent spawning + registry
Communication	SharedWorkspace (versioned, append-only log) + agent.inject()	State passing via graph edges with reducers	Task context chaining + Flow state	Session-based messages
Planning phase	UNDERSTAND → PLAN → APPROVE → EXECUTE → REPORT	Custom via graph design	Built-in planning=True	Not available
Patterns	Routing-based (direct, delegated, orchestrated)	Supervisor, Swarm, Hierarchical, Pipeline	Sequential, Hierarchical	Flat subagent tree
Cross-framework	Not yet	Not yet	A2A protocol (first-mover)	ACP protocol

OneRingAI's advantage: Three routing modes combine direct assignment, interactive delegation with monitoring, and a structured planning phase. SharedWorkspace gives agents a versioned bulletin board for coordination.

8. Multi-Modal Support

Feature	OneRingAI	LangChain / LangGraph	CrewAI	OpenClaw
Image generation	Built-in (GPT Image 2, Gemini 3.1 native generation/editing with normalized sizes and multi-image requests, Imagen, Grok Imagine)	Via community packages	DALL-E tool via crewai-tools	Via skills/extensions
Video generation	Built-in (Sora 2 with lifecycle metadata, Veo/Omni, Grok Imagine Video 1.5)	Not native	Not supported	Not built-in
TTS / STT	Built-in OpenAI, Google, and xAI TTS/STT, response-accurate xAI audio formats, raw 8 kHz telephony, normalized Gemini timestamps, multichannel xAI STT, strict 24 kHz OpenAI Realtime, and typed 8–48 kHz xAI Voice Agent sessions	Community packages	Not supported	Via extensions
Model registries	Dedicated registries: 20 image, 10 video, 7 TTS, 14 STT, and 15 embedding records with schema-v2 metadata	No registries	No registries	No registries

Why OneRingAI wins: A complete multimodal pipeline in one library — text, images, video, embeddings, TTS, STT, and realtime speech-to-speech with typed lifecycle-aware registries.

9. MCP (Model Context Protocol)

Feature	OneRingAI	LangChain / LangGraph	CrewAI	OpenClaw
MCP support	Native: stdio + HTTP/HTTPS, auto-reconnect, health checks, resource & prompt support	@langchain/mcp-adapters v1.1.0 (stdio + HTTP + SSE)	Native: stdio + HTTP + SSE, retry with backoff	Via mcporter bridge
Registry pattern	MCPRegistry.create() / MCPRegistry.get() for managing multiple servers	MultiServerMCPClient	MCPServerConfig on agent	Not native
Health monitoring	Periodic ping, connect/disconnect/error events	Configurable reconnection	Retry with exponential backoff	Not built-in

Why OneRingAI wins: First-class MCP integration with a registry pattern, health monitoring, and auto-reconnect for managing multiple servers.

10. Enterprise & Production Readiness

Feature	OneRingAI	LangChain / LangGraph	CrewAI	OpenClaw
Resilience	Circuit breakers (per-connector + per-tool), retry w/ backoff + jitter, rate limiting	Basic retries; no circuit breakers	Basic retry; no circuit breakers	Provider failover
Multi-tenant	userId scoping, connector allowlist, OAuth token isolation, StorageContext	Namespace-based primitives; application isolation is host-defined	Team/RBAC controls in CrewAI Enterprise; application isolation is host-defined in OSS	Designed around a single-user trust boundary
Observability	Logger + Metrics + EventEmitter — no SaaS required	LangSmith tracing has a free developer allocation and paid higher-volume tiers	Event listeners in OSS; managed tracing in CrewAI Enterprise	Event bus
API stability	Semantic versioning, TypeScript strict mode	Frequent breaking changes	Memory system rewritten; some API churn	CalVer (daily releases)
Tests	6,500+ unit tests across 300+ files, plus authenticated live API checks	Vitest matchers (recently added)	Comprehensive pytest suite	Community testing

11. Summary: Why OneRingAI

Dimension	OneRingAI Advantage	vs LangChain	vs CrewAI	vs OpenClaw
Runtime	One observable lifecycle for complete native OneRingAI and Codex SDK agent systems	LangGraph runtime and deployment surfaces	Crew and Flow execution	Product-owned runtime
Auth	Connector-first architecture with built-in multi-service OAuth 2.0	Credentials per model/tool integration	Credentials per model/tool integration	Auth profiles per extension
Security	3-tier permission system with 8 policy types	Guardrails, middleware, and HITL; no equivalent permission manager	Guardrails and human feedback; managed RBAC in Enterprise	Tool policy, sandbox, and exec approvals
Resilience	Built-in per-tool circuit breakers + rate limiting	Retries/fallback middleware; no equivalent per-tool circuit breaker	Retries and callbacks; no equivalent per-tool circuit breaker	Provider failover and execution policy
Context	Plugin-based context + InContextMemory + per-plugin token budgets	Split memory systems	Good Memory, no plugin system	Not developer-accessible
Multi-modal	Single library: text + image + video + embeddings + TTS + STT + realtime voice	Requires community packages	Minimal support	Via extensions only
Desktop	Portable native-Agent packages, trusted-host hydration, local/remote tools, browser-safe Realtime peer, and 11 computer-use tools	Not built-in	Not built-in	Not built-in
TypeScript	Full strict mode type safety	TS but heavy abstraction layers	Python-only	TS but not a developer SDK
Enterprise	Multi-tenant primitives, permissions, hooks — built into the library, no SaaS required	LangSmith offers a free developer trace allocation; paid tiers add scale and team features	Managed deployment, observability, and RBAC are available in CrewAI Enterprise	Self-hosted and designed around a single-user trust boundary

OneRingAI is a stable, connector-first TypeScript foundation for production agents, plus an optional observable runtime for complete agent systems: current vendor APIs, lifecycle-aware registries, portable execution, Agent-aware Realtime, auth, security, resilience, orchestration, tools, and context management in one package.

Sources and scope. OneRingAI facts updated from release 1.1.3 source and documentation on 30 August 2026. Competitor capabilities were last checked against primary documentation on 9 August 2026:

LangChain models, middleware, guardrails, and LangSmith billing; CrewAI OSS documentation and CrewAI Enterprise; OpenClaw tools and exec approvals. Counts, prices, and managed-product limits change frequently; verify them before quoting.