AgentOS Developer Docs

English

简体中文

English

简体中文

Appearance

AgentOS Developer Docs ​

This site is the unified entry point for developers building apps with AgentOS.

These docs now include not only traditional explanations and examples, but also reusable prompts and fact checklists you can send directly to Claude, Codex, Cursor, ChatGPT, and similar AI coding tools.

AgentOS Docs

Let developers spend their time on scenario innovation.

AgentOS is valuable because it brings the model gateway, agent assembly layer, multimodal capabilities, and RAG services together. Developers can validate their own vertical scenarios faster instead of first solving where models come from, how agents should be orchestrated, or how RAG should be built.

AI Coding Tools

Prepare the right context first, then hand the integration to AI

If you already use Claude, Codex, Cursor, or ChatGPT to write integration code, start with the AI-assisted integration page and copy the prompt templates plus fact checklists before reading full tutorials.

ModelKit

A ready model gateway so you do not have to worry about model sourcing

AgentOS ships with ModelKit, so developers do not have to solve model supply, user-side model setup, or provider differences first. If your app already has a complex agent, you can use AgentOS directly as an OpenAI-compatible gateway.

AgentKit

You know your tools and scenario, but do not want to build the agent layer yourself

If you are not deeply familiar with agent implementation, or simply do not want to maintain sessions, tool orchestration, and message flow, AgentKit is the fastest way to validate the scenario.

Multimodal

LLM, image support, TTS, ASR, and embeddings in one gateway

Developers do not need to find separate providers or force end users to bring their own model setup. ModelKit already exposes text, image understanding, TTS, ASR, and embeddings through one unified gateway surface.

RagKit

You need RAG, but do not want to build it from scratch

For apps that need knowledge bases, document management, and retrieval, RagKit provides query, docs management, and ingestion workflows so you can skip the lower-level vector infrastructure work.

Before spending time on an Agent App, first decide whether your scenario truly needs an agent ​

AgentOS is great for helping developers build agent apps faster, but not every AI scenario should become an agent.
Based on two official OpenAI guides, agents are usually worth the investment only when your workflow combines multi-step decision making, tool or system interaction, and genuine ambiguity.

You can read the original guides here:

When an Agent App is a strong fit ​

It requires a multi-step workflowThe job is not “generate one answer and stop.” The system needs to decide what to do next, when to stop, when to retry, and when to hand control back to the user.
It needs tools or external systemsThe scenario goes beyond chat and must read documents, query data, call APIs, update records, or trigger actions across systems.
The problem is ambiguous and judgment-heavyIf the work looks more like an experienced analyst than a fixed rules engine, an agent is often a better fit.

When you should not rush into building an Agent App ​

It is only a single-step generation taskIf the feature is mainly Q&A, summarization, rewriting, translation, or classification, a regular LLM feature may be enough.
The workflow is deterministicIf your rules, branching logic, and approvals are already very clear, traditional workflow automation or a rules engine is often more reliable and cheaper.
The need is capability access, not agent orchestrationIf what you really need is TTS, ASR, embeddings, search, or document Q&A, start with those capabilities directly instead of building an agent first.

If it is not an agent scenario yet, what should you build instead? ​

In Identifying and scaling AI use cases, OpenAI groups many practical AI opportunities into six lower-level primitives:

  • Content creation
  • Research
  • Coding
  • Data analysis
  • Ideation and strategy
  • Automation

If your scenario looks more like one of these primitives than a system independently executing workflows, then an Agent App may not be the right next step.
In that case, it may be better to build:

  • a text or multimodal feature on top of modelkit
  • a direct tts / asr / embeddings capability page
  • a knowledge feature on top of ragkit
  • a regular workflow automation or rules-based system

Why developers typically choose AgentOS ​

  • They do not want to build a separate model platform first and would rather focus on their product-specific scenario
  • They already know their tools and domain flow well, but do not want to implement agent orchestration from scratch
  • They need more than text models, including image support, TTS, ASR, and embeddings, and want them behind one gateway
  • They need RAG, but do not want to start from embeddings, vector stores, and document lifecycle plumbing

Where to start ​

  • If you plan to hand the task directly to an AI coding tool, start with AI-Assisted Integration
  • If you already have your own complex agent and only need model access, start with TypeScript Quickstart
  • If you want to decide between ModelKit, AgentKit, and RagKit, start with Choose Your Stack
  • If you are building for Dart or Flutter, start with Dart Quickstart
  • If you want to see working code first, go straight to examples/

Common entry points ​

AI-assisted integrationGet prompt templates, fact checklists, and manual verification steps for AI coding tools.Choose your stackQuickly identify whether your scenario is “already have an agent”, “have tools but not an agent”, “need RAG”, or “need the model gateway only”.TS minimal appThe fastest path to validate OpenAI-compatible integration, model calls, and the AgentOS gateway itself.Dart chat appUseful when you want to understand SDK integration, ChatKit UI patterns, and host-side Flutter coordination together.

Doc structure ​

  • getting-started/: onboarding and quickstarts
  • concepts/: published concept pages
  • guides/: polished task-oriented guides
  • examples/: minimal and integration examples
  • draft/: work-in-progress references, outlines, and draft pages

Documentation sources ​

This repository only maintains the documentation source text and information architecture. Implementation details and API facts come from the following source repositories: