SmythOS SRE: Open-Source AI Agent Runtime with Unified Provider Abstraction

What SmythOS SRE Does and Who It Targets

AI agents require access to several classes of infrastructure: language models to generate responses, vector databases for retrieval, storage for files and artifacts, and caches for performance. Without an abstraction layer, agent code becomes coupled to specific providers: code written for OpenAI breaks when the team switches to Anthropic, and code using S3 requires a rewrite for Google Cloud Storage.

SmythOS SRE addresses this by providing OS-level abstractions for each resource class. The README describes the design principle: every provider exposes the same functions and APIs regardless of the underlying implementation. An agent that stores a file through the SRE API works identically whether the configured backend is a local filesystem, S3, Google Cloud, or Azure. The same principle applies to LLMs, vector databases, caches, and secret stores.

The target audience is developers building production AI agents who need both provider flexibility and built-in infrastructure concerns such as access control, observability, and lifecycle management. The README positions the project as the missing operating system layer for AI agents.

Three-Package Monorepo: Core, SDK, and CLI

The repository is a pnpm workspace with three main packages. The packages/core package is the SRE kernel: the runtime environment that manages resource connectors, enforces the Candidate/ACL security model, handles agent orchestration, and provides the 40+ production-ready components. Engineers who want direct control over the runtime or need to extend it with custom connectors work at this level.

The packages/sdk package is the developer-facing abstraction layer. It provides a clean TypeScript interface with IntelliSense support, designed to look the same in development and production. The SDK depends on the core runtime but hides its setup complexity.

The packages/cli package scaffolds new projects. The README recommends the CLI as the primary starting point because it walks through configuration choices interactively. Build tooling uses pnpm workspaces with Vite and TypeScript 5.8.3 as the compiler, and tests run through Vitest.

Installing SmythOS SRE and Creating the First Agent

The CLI is the recommended installation path. Install it globally and then scaffold a new project:

npm i -g @smythos/cli
sre create

The CLI guides through project configuration. For adding the SDK to an existing project:

npm install @smythos/sdk

Once installed, agents are created either by importing a .smyth file built with the visual SmythOS Studio, or by defining agent logic in TypeScript. Loading and running a .smyth file requires specifying the model:

const agent = Agent.import(agentPath, {
    model: Model.OpenAI('gpt-4o'),
});
const result = await agent.prompt('Hello, how are you ?');

The prompt method returns the full response by default. The SDK also supports a streaming mode where the caller listens to content events as they arrive, end events when the response completes, and usage events for token accounting. For debugging startup or configuration issues, the README instructs setting the LOG_LEVEL environment variable to debug before running.

Supported Connectors and the Candidate/ACL Security Model

The connector set covers five resource categories. Storage backends include local filesystem, Amazon S3, Google Cloud Storage, and Azure Blob Storage. LLM providers include OpenAI, Anthropic, Google AI, AWS Bedrock, Groq, and Perplexity. Vector database connectors cover Pinecone, Milvus, and a RAM-backed in-process option called RAMVec. Cache backends are RAM and Redis. Secret storage supports a JSON file vault, AWS Secrets Manager, and HashiCorp Vault.

Security is implemented through a Candidate/ACL system built into the runtime kernel. The README lists this as a first-class design principle rather than an add-on feature. Every agent runs under a candidate identity, and access to resources is mediated by access control rules configured in the runtime. This means security policy is declared at the infrastructure level rather than written into each agent's application code.

The same abstraction that makes providers swappable also applies to security: switching from a local JSON vault to AWS Secrets Manager does not require changing the agent's credential retrieval logic, only the runtime configuration.

The .smyth File Format and the Visual Studio Option

SmythOS agents can be defined in two ways. Engineers who prefer code use the TypeScript SDK directly. Teams or individuals who prefer a visual interface can use SmythOS Visual Agent Studio, a separate open-source project that the README links to as SmythOS/smythos-studio on GitHub. Visual Studio produces .smyth files, which the SDK loads with Agent.import().

The .smyth extension is the proprietary pipeline format for SmythOS-built agents. Loading a .smyth file requires the SmythOS SDK, which creates an ecosystem dependency: agents serialized in this format cannot be run by an unrelated runtime. Teams who want to keep agent definitions portable should define them in TypeScript using the SDK's code-first API and treat .smyth files as an optional authoring artifact rather than the primary artifact.

The SDK also includes an examples directory at the root with numbered scenarios covering agent code skills, .smyth file loading, workflow components, vector database operations with and without an agent, storage operations, custom SRE configuration, WebApp worker mode, Zoom integration, local models, scheduling, observability, and vaults.

Limitations and Maintenance Status

The repository has no tagged GitHub releases at version 0.5.0. Teams adopting SmythOS SRE are pinning to a commit on the main branch rather than a semantic version. The absence of releases complicates dependency management for projects that want reproducible builds and clear upgrade paths.

An alternative for teams building AI agents in TypeScript is LangChain.js, which is a JavaScript/TypeScript framework providing abstractions for LLMs, chains, retrieval, and memory. The key difference is that LangChain.js focuses on chaining model calls and retrieval steps, while SmythOS SRE positions itself as a lower-level operating system layer with explicit security, storage, and lifecycle management as first-class concerns. Teams whose primary need is chaining model calls with retrieval may find LangChain.js more focused; teams building long-running agents that need access control and multi-provider resource management may find SmythOS SRE's abstraction model better matched to their requirements.

The last push to the main branch was on 2026-04-03. No GitHub releases have been published.

Editorial conclusion

SmythOS SRE fits teams who want a production-grade runtime that abstracts provider differences at the infrastructure level, so agent business logic does not need to change when switching between OpenAI and Anthropic or between S3 and local storage. The security-first Candidate/ACL system and built-in observability are advantages over assembling the same capabilities from individual libraries. The .smyth file format ties pipelines to the SmythOS ecosystem: teams should verify whether that dependency is acceptable before building a large agent library around it. The last push to the main branch was on 2026-04-03, and the repository has no tagged releases, meaning teams building on it are tracking the main branch rather than a versioned artifact.

Frequently asked questions

Official sources

1. Issues
2. License: MIT
3. Project website
4. README
5. SmythOS/sre on GitHub