Agentos
The agent OS that evolves itself.
Last verified:
What is Agentos?
AgentOS is an open-source TypeScript runtime for autonomous AI agents that remember, adapt, and write their own tools. It transforms AI coding agents from confused interns into productive developers through structured workflows that capture your standards, stack, and unique codebase details. The runtime provides cognitive memory with 8 neuroscience-grounded mechanisms, HEXACO personality modulation, runtime tool forging in node:vm sandboxes, and unified graph orchestration across 16-25 LLM providers.
Key features include deep research agents with Tree of Thought planning, full-duplex voice & IVR pipeline with telephony bridging, streaming guardrails with 5-tier security, multimodal API for text/images/video/music/speech, capability discovery with 89% token reduction, provenance & audit with signed event ledgers, and 100+ first-party extensions including channel adapters for Telegram, Discord, Slack, WhatsApp, Twitter/X, LinkedIn, and more. The system supports multi-agent teams with 6 coordination strategies and emergent capabilities where agents forge new tools at runtime.
AgentOS is designed for developers building adaptive multi-agent systems, AI automation agencies, production AI agents needing observability, teams shipping agents to production, and researchers wanting reproducible benchmarks. It's used in production by developers who need agents that remember across sessions, self-improve through bounded self-modification, and maintain consistency through personality-driven routing under Apache 2.0 license.
Agentos pricing
Pricing model: Freemium
AgentOS core runtime (@framers/agentos) is free and open-source under Apache 2.0 license with no cost to install or use. The hosted platform at agentos-ai.dev offers: Free tier at $0 forever for solo developers with up to 3 agents, 7-day event retention, 1,000 runs/month, email alerts, and community support. Pro tier at $49/month for teams with unlimited agents, 30-day retention, 50,000 runs/month, webhook alerts, AI daily reports, and priority support. Enterprise tier at custom pricing for scale with unlimited everything, 2-year retention, custom rate limits, SSO/SAML, SLA + dedicated support, and on-prem option. No credit card required to start free tier. Self-hosted deployments use the open-source package with no hourly/run fees beyond LLM provider costs.
Agentos pros
- Open-source under Apache 2.0 license with full transparency
- 85.6% accuracy on LongMemEval-S benchmark, beating Mastra by 1.4 points
- 70.2% on LongMemEval-M (1.5M tokens), only open-source library above 65%
- Runtime tool forging lets agents create new TypeScript functions mid-session
- 8 neuroscience-backed cognitive memory mechanisms with Ebbinghaus decay
- HEXACO personality vectors modulate memory retrieval and decision-making
- 16-25 LLM providers unified under one API surface with fallback chains
- Multi-agent orchestration with 6 strategies including hierarchical spawning
- 5-tier streaming guardrails covering PII, ML classifiers, code safety, grounding
- Full-duplex voice pipeline with Twilio/Telnyx/Plivo telephony bridging
- 100+ first-party extensions and 88 curated SKILL.md skills auto-discovered
- Graph orchestration with AgentGraph, workflow() DSL, and mission() APIs
- Checkpointing enables time-travel debugging for agent workflows
- Per-claim citation verification with supported/weak/unverifiable/contradicted verdicts
- Single-CLI benchmark reproduction with agentos-bench at seed=42
- Immutabled agents with sealed storage policy and toolset pinning
- Video and audio generation APIs with 3 video and 8 audio providers
- Capability discovery reduces tokens by 89% through 3-tier semantic search
- Provenance audit with Ed25519 signatures and Merkle anchoring
- Works alongside Claude Code, Cursor, and existing development workflows
Agentos cons
- TypeScript-only implementation limits non-JavaScript ecosystem users
- Runtime tool forging requires LLM judge approval adding latency per tool
- Node:vm sandbox has 5-second wall clock and 128 MB heap-delta limits
- HEXACO personality is opt-in and most production deployments don't use it
- First forge of a tool costs full LLM tokens before reuse becomes cheap
- Documentation is auto-generated from source with 0 guides currently available
- Whitepaper is still coming soon not yet available for citation
- No hosted multi-tenant tier documented for production deployment
- Sandbox isolation uses node:vm not isolated-vm for single-tenant only
- Provider fallback is opt-in off by default requiring explicit configuration
- MaxSteps default of 5 may be too low for complex multi-tool workflows
- Emergent capabilities require LLM-as-judge safety review adding complexity
- 2-year retention only available on custom Enterprise plan not self-hosted
- Cross-provider benchmark numbers excluded due to undisclosed methodology
- LOCOMO benchmark has approximately 6.4% answer-key error rate noted
- Context pressure can dissolve prompt-only personality without kernel encoding
Frequently asked questions about Agentos
What is AgentOS and what problem does it solve?
AgentOS is an open-source TypeScript runtime for autonomous AI agents that remember, adapt, and write their own tools. It solves the problem of AI agents losing context across sessions, being unable to create new capabilities when encountering unfamiliar tasks, and lacking consistent personality-driven behavior. The runtime provides cognitive memory with 8 neuroscience-grounded mechanisms, runtime tool forging in hardened node:vm sandboxes, and HEXACO personality modulation that persists across sessions unlike prompt-only personality which dissolves under context pressure.
How does runtime tool forging work?
When an agent encounters a sub-task no existing tool covers, it generates a TypeScript function with a Zod-described input/output schema. A separate LLM call evaluates the forged function against the agent's stated intent and either approves or rejects it. Approved functions execute in a hardened node:vm sandbox with strict defaults: 5-second wall clock, 128 MB heap-delta budget, eval/require/process banned, and empty allowlists for fetch/fs/crypto by default. Approved tools join a discoverable index keyed by name and signature for subsequent turns via call_forged_tool(name, args). First forge costs full LLM tokens but reuse costs tens of tokens.
What benchmarks does AgentOS achieve?
AgentOS achieves 85.6% accuracy on LongMemEval-S (115K tokens, 50 sessions) at $0.0090 per correct answer using gpt-4o reader, which is +1.4 points above Mastra OM gpt-4o at 84.23% and 0.4 points behind Emergence.ai's closed-source 86%. On LongMemEval-M (1.5M tokens, 500 sessions), AgentOS achieves 70.2%, the only open-source library on public record above 65% on M with publicly reproducible methodology. Benchmarks use bootstrap 95% CIs at 10k Mulberry32 resamples at seed 42 with per-case run JSONs available for reproduction.
Which LLM providers are supported?
AgentOS supports 16-25 LLM providers including OpenAI, Anthropic, Gemini, Groq, Ollama, OpenRouter, Together, Mistral, xAI, Claude CLI, Gemini CLI, plus 5 image/video providers. Provider auto-detection reads from environment variables in the order: OpenRouter → OpenAI → Anthropic → Gemini → Groq → Together → Mistral → xAI → Claude CLI → Gemini CLI → Ollama. Default models per provider are documented, with gpt-4o as OpenAI default and claude-sonnet-4-5-20250929 as Anthropic default. Provider fallback is opt-in via fallbackProviders configuration.
How does cognitive memory work?
Cognitive memory uses 8 neuroscience-grounded mechanisms: Ebbinghaus decay, retrieval-induced forgetting, involuntary recall, FOK (feeling-of-knowing), gist extraction, schema encoding, source-confidence decay, and emotion regulation. Memory is gated through three LLM-as-judge classifiers in a single shared pass: QueryClassifier categorizes queries into T0 (none/memory-unnecessary) through T3 (complex), MemoryRouter selects the right architecture (canonical-hybrid, OM-v10, or OM-v11), and ReaderRouter selects gpt-4o for TR/SSU categories or gpt-5-mini for SSA/SSP/KU/MS. The T0 no-memory gate skips retrieval entirely for greetings and small talk, saving embedding + rerank + reader cost on substantial traffic fractions.
What is HEXACO personality and when should I use it?
HEXACO personality is an optional 6-trait vector (honesty, emotionality, extraversion, agreeableness, conscientiousness, openness) with 0-1 values that biases memory retrieval, specialist routing, and decision-making at the kernel level rather than just in the prompt. Default is neutral 0.5 on every axis. When a vector is supplied, the runtime appends a trait-derived directive to the system prompt and modulates three cognitive-memory mechanisms based on honesty/emotionality/openness. Personality is opt-in and most production deployments don't pass one. Use it when persona consistency across sessions matters, like career coaches holding users accountable to stated goals across weekly check-ins.
How do multi-agent teams work?
Multi-agent teams use agency() with 6 coordination strategies: sequential, parallel, debate, review-loop, hierarchical, and graph. Agents share memory and can communicate via inter-agent messaging with HITL gates. With strategy 'hierarchical' and emergent enabled, the manager LLM gets a spawn_specialist tool that mints new sub-agents at runtime when the static roster doesn't cover a sub-task. The runtime compiles AgentGraph, workflow() DSL, and mission() APIs to one IR with judgeNode for evaluation and checkpointing for time-travel debugging. Multi-agent orchestration can spawn specialists dynamically when capability gaps are encountered.
What guardrails and safety features are included?
AgentOS includes 5-tier streaming guardrails pipeline: PII redaction using regex + NLP + NER + LLM, ML classifiers using ONNX BERT, topicality drift detection, code safety following OWASP guidelines, and grounding guard using NLI (natural language inference). The pipeline is sentence-boundary buffered for real-time streaming. Per-claim citation verification decomposes responses into atomic claims and scores each against sources via cosine similarity with optional NLI for contradiction detection, returning verdicts of supported, weak, unverifiable, or contradicted. Runtime tool forging includes LLM-as-judge safety review before approval. Provenance uses Ed25519 signatures with SHA-256 hash chains and Merkle anchoring for tamper-evident verification.
How do I install and get started with AgentOS?
Install via npm install @framers/agentos. Set API keys via environment variables (OPENAI_API_KEY, ANTHROPIC_API_KEY, GEMINI_API_KEY) or pass apiKey inline. Basic usage: import { agent } from '@framers/agentos', create an agent with agent({ provider: 'openai', model: 'gpt-4o', instructions: '...', memory: { enabled: true, cognitive: true } }), create a session with tutor.session('user-id'), and send messages with session.send(). Provider keys can be set via env or passed inline, with auto-detection from environment when provider is omitted. Full quickstart, examples cookbook, and API reference are available in the docs.
What channels and integrations are supported?
AgentOS supports 37 platform adapters including Telegram, Discord, Slack, WhatsApp, Twitter/X, LinkedIn, Bluesky, Mastover, and custom adapters. The extensions package @framers/agentos-extensions includes 100+ first-party extensions: channel adapters, tool packs, integrations, and guardrail packs. Extensions and skills auto-load at startup through the registry system - the runtime walks each registry plus user-supplied paths, resolves factory functions or SKILL.md frontmatter, and registers tools, guardrails, channels, and skills without manual wiring. Multi-channel routing, social publishing, browser automation, and adapter APIs are included. Voice pipeline integrates with ElevenLabs, Deepgram, Whisper for TTS/STT and Twilio, Telnyx, Plivo for telephony.