AgentOS is an open-source TypeScript framework, published on npm as @framers/agentos, for building autonomous AI agents that remember, adapt, and write their own tools.

What it is

AgentOS is a TypeScript framework for building autonomous AI agents, distributed under the Apache-2.0 licence and maintained in the framerslab/agentos repository. It lives in the JavaScript and TypeScript ecosystem, requires TypeScript 5.4 or newer, and installs as a single npm package. The framework is built around three concerns that its authors treat as one system: persistent cognitive memory, runtime tool creation, and coordination between multiple agents. The project is also an NVIDIA Inception member and publishes benchmark results through a separate repository, framerslab/agentos-bench.

The concrete problem it addresses is session amnesia in long-running agent deployments. Most agent libraries hand a model a conversation history and lose everything when the process ends, and most require the developer to pre-declare every tool an agent may call. AgentOS replaces both patterns. It provides a persistent memory layer modelled on eight neuroscience-backed mechanisms, including Ebbinghaus decay, retrieval-induced forgetting, reconsolidation, and source-confidence decay, so that what an agent retains degrades and reconsolidates rather than accumulating forever. Alongside that, it replaces the static tool registry with a forge: an agent writes a TypeScript function with a Zod schema, an LLM judge approves it, and the function runs in a hardened node:vm sandbox before joining the catalog for the remainder of the session.

Key capabilities

• Persistent cognitive memory driven by eight neuroscience-backed mechanisms, including Ebbinghaus decay, retrieval-induced forgetting, reconsolidation, and source-confidence decay.
• Runtime tool forging, where an agent writes a TypeScript function with a Zod schema, an LLM judge approves it, and the function executes in a hardened node:vm sandbox before joining the session catalog.
• One dispatch interface across 11 LLM providers, with the provider auto-detected from the environment when the provider option is omitted.
• Optional HEXACO personality traits, configured as numeric dimensions such as openness and conscientiousness in the agent definition.
• Six orchestration strategies for multi-agent collaboration, exercised in the repository by examples/emergent-hierarchical-spawning.mjs.
• Guardrails and a voice pipeline, listed among the framework's documented feature areas.
• Startup auto-loading of 100 or more extensions and 88 skills.
• Published memory benchmarks of 85.6% on LongMemEval-S at $0.0090 per correct answer with gpt-4o, and 70.2% on LongMemEval-M.

Who uses it and how

• Teams building long-running assistants that must retain context across sessions rather than resetting to a blank history at each invocation.
• Developers working in TypeScript who want agent definitions expressed as typed code, with a Zod schema gating any function an agent writes for itself.
• Projects that need to switch or spread load across model providers, since a single dispatch interface covers 11 providers and resolves a default model per provider, such as claude-sonnet-4-6 for Anthropic unless a specific model is pinned.
• Builders of multi-agent systems, who can apply one of six orchestration strategies and reproduce hierarchical spawning from the bundled example.
• Applications that want configurable agent temperament, expressed through optional HEXACO personality dimensions.

Getting started

Install the package with npm install @framers/agentos, then import the agent function and construct an agent with a provider, instructions, optional personality traits, and a memory configuration. The provider can be supplied explicitly or detected from the environment, and the framework auto-loads its extensions and skills at startup.

How it compares

The facts provided for this page do not name any other tool, paid or otherwise, that AgentOS is positioned against, so no product-by-product contrast can be drawn. It stands alone in this registry on the basis of the material available.

When to use it — and when not to

Choose AgentOS when an agent needs durable memory across sessions or needs to extend its own toolset without a developer writing each function in advance, and when the application is Node-based, since runtime tool forging depends on node:vm. Skip it if the target runtime is a browser or an edge environment where node:vm is unavailable, or if the project requires documentation of self-hosting infrastructure, because the material provided does not identify any backing database, object storage, or mail service that a self-hoster would have to operate. The README also does not describe a hosted option, so adopting AgentOS means running it inside an application the adopter already controls.

npm install @framers/agentos

import { agent } from '@framers/agentos';

const tutor = agent({
  provider: 'anthropic',                          // resolves to claude-sonnet-4-6 (provider default)
  // model: 'claude-opus-4-8',                    // pin a specific model to override the default
  instructions: 'You are a patient CS tutor.',
  personality: { openness: 0.9, conscientiousness: 0.95 },
  memory: { types: ['episodic', 'semantic'], working: { enabled: true } },
});

// Provider auto-detected from env when `provider` is omitted.

const session = tutor.session('student-1');
await session.send('Explain recursion with an analogy.');
await session.send('Can you expand on that?'); // remembers context

// Before 0.10 — stateless unless memory was on:
const s = agent({ model, memory: false }).session('job-1'); // kept no history

// 0.10 — sessions remember by default; opt out explicitly:
const stateless = agent({ model, memory: false, history: false }).session('job-1');
const bounded = agent({ model, history: { maxTokens: 60_000 } }).session('job-2');
bounded.reseed([{ role: 'user', content: 'compact resume snapshot' }]);

import { souledAgent } from '@framers/agentos';

const aria = await souledAgent({ provider: 'anthropic', soul: '~/.agentos/agents/aria' });