Skip to main content
Durable agents for production Go systems

Chronos turns agent prototypes into reliable software.

Build AI agents that plan, call tools, remember context, collaborate in teams, and resume long-running work after failures.

Start buildingView architecture
$ curl -fsSL https://raw.githubusercontent.com/spawn08/chronos/main/install.sh | bash
agent run · session-42
1Input
2Guardrails
3Model
4Tools
5Checkpoint
6Stream
startplantoolreviewdonecheckpointresume
Go-nativetyped SDK and runtime
Durablecheckpoints and resume
Pluggablemodels, storage, vectors
Governedauth, approval, audit
Platform

One stack for building, running, and governing agents

Chronos keeps application code clean while the runtime handles durability, observability, and operational control.

Build

Agent SDK

Compose chat agents, deterministic StateGraphs, tools, memory, skills, and multi-agent teams from Go or YAML.

Run

Durable Runtime

Checkpoint graph progress, resume interrupted work, stream events, and scale workers over a lease-backed queue.

Govern

ChronosOS

Operate agents with auth, approvals, tracing, audit logs, rate limits, and production deployment patterns.

Architecture

A layered runtime with explicit seams

Swap model providers, storage backends, vector stores, tools, hooks, guardrails, and sandbox backends without rewriting your agents.

Explore diagrams
ChronosOSAuth · approvals · tracing · HTTP API
SDKAgent builder · teams · memory · knowledge
EngineStateGraph · tools · models · streaming
StorageSQL · NoSQL · vector adapters
Capabilities

Everything needed beyond the first demo

Provider-neutral models

OpenAI, Anthropic, Gemini, Mistral, Ollama, Azure OpenAI, Groq, DeepSeek, and OpenAI-compatible endpoints.

Tools with policy

Typed tool definitions, permissions, approval gates, sandboxed execution, and audit-friendly results.

Memory and RAG

Short-term context, long-term memory extraction, vector-backed semantic recall, and knowledge search.

Teams and delegation

Sequential, parallel, router, coordinator, and swarm-style collaboration for specialized agents.

Interoperability

Expose or consume agents through MCP, A2A, and AG-UI without coupling your application to one ecosystem.

Evaluation loop

Capture traces, create datasets, run evaluators, and gate regressions before changes reach production.

Quickstart

Start with YAML. Drop into Go when you need control.

Use declarative configuration for operations-friendly agents, then compose the same primitives directly from Go for product code.

Read quickstartAgent API
YAML agent
# .chronos/agents.yaml
agents:
  - id: support
    name: Support Agent
    model:
      provider: openai
      model: gpt-5.5
      api_key: ${OPENAI_API_KEY}
    system_prompt: You resolve customer issues clearly and safely.
    tools: [search_docs, create_ticket]
    memory:
      semantic_recall: true
Go builder
store, _ := sqlite.New("chronos.db")
store.Migrate(ctx)

a, _ := agent.New("support", "Support Agent").
    WithModel(model.NewOpenAI(os.Getenv("OPENAI_API_KEY"))).
    WithStorage(store).
    WithSystemPrompt("Resolve customer issues clearly and safely.").
    Build()

resp, _ := a.ChatWithSession(ctx, "session-42", "Help me debug my order")
fmt.Println(resp.Content)