Seshat Runtime MCP server
Commit Nov 12, 2026An open-source Go agent runtime that enables autonomous multi-agent execution with support for MCP, RAG, and over 60 built-in tools.
Also known as KPO-Tech/seshat-runtime
- Stars
- 5
- Tools
- —
- Downloads, 30 days
- —
- Latest version
- —
- Last commit
- Nov 12, 2026
- License
- Apache-2.0
What is Seshat Runtime MCP?
Seshat Runtime is an open-source Go agent runtime that enables autonomous multi-agent execution with support for MCP, RAG, and over 60 built-in tools.
Summary generated from the project's README
About Seshat Runtime MCP server
Developers needing a governed execution layer for autonomous agents can use this open-source Go runtime to manage multi-agent workflows. It provides a middle layer between simple chat interfaces and fragmented frameworks, allowing for self-hosted or local-first deployment. The runtime supports multi-provider routing across 15 different providers and includes over 60 built-in tools such as sandboxed bash, web browsing, and RAG capabilities.
Users can interact with the system through a CLI/TUI, gRPC, or by embedding the Go SDK directly into their own applications. The runtime handles persistent sessions, permissions, and failure recovery, making it suitable for serious infrastructure needs. It integrates with MCP servers to extend its functionality and can be deployed under your own rules without vendor lock-in.
What you can do with it
- 1Execute parallel multi-agent researchA developer can assign a complex research task that triggers multiple sub-agents to work in parallel.
- 2Embed agentic capabilities in Go appsSoftware engineers can integrate the runtime directly into their existing Go-based internal systems or applications.
- 3Manage long-running agent sessionsUsers can utilize the terminal interface to maintain persistent sessions with audit-friendly behavior and session recovery.
Written from the project's README. Every use case is checked against a quote from it.
Configuration
ANTHROPIC_API_KEY
Automated checks
Ran Nov 14, 2026Full report →Not verified yet. A server needs a score of 80, no serious finding, and enough data for us to check. How checks work · What to fix for more points
- Source repository linked and reachablekpo-tech/seshat-runtime is public and reachablegithub.com/kpo-tech/seshat-runtime ↗Pass
- Package names this repository as its sourceNot checked
- Build provenance (Sigstore attestation)Not checked
- Open source license (OSI)Apache-2.0spdx.org/licenses/Apache-2.0.html ↗Pass
- Commit or release in the last yearLast commit or release 2026-11-12github.com/kpo-tech/seshat-runtime ↗Pass
- OpenSSF ScorecardNot checked
- Package name not close to a popular packageNot checked
- No critical advisory in the package or its dependenciesNot checked
- No hidden instructions to the model0 tool descriptions and the README read; no override phrases, credential paths or hidden charactersPass
- Destructive tools are labelledNot checked
- Remote endpoint answers the MCP handshakeNot checked
README
View on GitHubWhat Seshat Is Today
Seshat is an open-source Go agent runtime for people who need more than a chat shell and less vendor lock-in than a closed assistant.
Its current wedge is concrete:
- governed multi-turn agent execution
- tools, files, sandboxed bash, web, browser, MCP, RAG, and skills
- multi-provider routing with self-hosted and local-first deployment options
- persistent sessions, permissions, recovery, and audit-friendly behavior
- CLI/TUI, gRPC, and Go SDK surfaces on the same runtime core
If you want the class of tool people reach for in products like Claude Code, but open, written in Go, multi-provider, and deployable under your own rules, this is the project.
Why This Exists
Most of the market still splits into two weak extremes:
- chat products that answer well but do not own serious execution
- low-level frameworks that are flexible but too fragmented, too provider-shaped, or too awkward to ship as a real runtime
Seshat is the missing middle layer: an execution runtime that can actually run agents, call tools, hold sessions, enforce permissions, recover from failures, and stay usable as infrastructure.
The Broader Open-Source Direction
The project still keeps a broader ambition, and that matters for the community.
Seshat is not only about making one strong solo agent. The longer-term direction is organized agentic work: explicit roles, mission memory, structured coordination, durable teams, and an open foundation that others can extend through skills, MCP servers, SDK integrations, and domain-specific workflows.
That larger vision belongs in the docs and in open-source discussion because contributors need the map, not only the current feature list.
- Product and runtime direction: https://seshat-ai.com/en/docs/learn/vision
- Runtime concepts and architecture: https://seshat-ai.com/en/docs/concepts/what-is-seshat
- Technical bets behind the project: https://seshat-ai.com/en/docs/learn/technical-hypotheses
- Why the runtime is written in Go: https://seshat-ai.com/en/docs/learn/why-go
Runtime First, Platform Above It
Seshat is the runtime layer.
Use this repository if you want to:
- run agents locally or self-host them under your own control
- embed the runtime inside a Go application or internal system
- extend providers, tools, permissions, MCP integration, or runtime behavior
If you want a ready-to-use product built on this engine, see SeshatOS (local-first desktop app and backend) or SeshatCloud (multi-tenant server and admin console for organizations).
🖥️ Terminal UI
seshat chat drops you into a full-featured terminal interface built for long-running agent sessions.
Keyboard shortcuts:
ctrl+psettings ·ctrl+lmodels ·ctrl+ssessions ·ctrl+,providers ·ctrl+nnew session ·ctrl+ttasks ·ctrl+ucopy last response ·ctrl+ytoggle yolo ·ctrl+oopen editor ·ctrl+ghelp ·ctrl+cquitNew line in the prompt:
ctrl+jworks in every terminal.shift+Enterandctrl+Enterneed a terminal that tells them apart fromEnter; Windows Terminal and the VS Code terminal do not by default, so runseshat terminal-setup(the setup scripts offer it): it writes the key bindings into their settings, after backing the file up, and--checkpreviews it. Terminals with a keyboard protocol (kitty, WezTerm, Ghostty, foot, recent Alacritty, iTerm2) need nothing.
Clipboard note (Linux): selection copy works best when
wl-clipboard(Wayland) orxclip/xsel(X11) is installed. Without a system clipboard backend, Seshat can request terminal clipboard access but cannot guarantee a real system copy.
Compaction note: transcript compaction is automatic today. A dedicated manual compact action is planned for the TUI once the runtime exposes a real manual-compaction hook.
🌐 The Seshat Ecosystem
seshat is the headless runtime: pure Go, no UI, no users, no billing. It is the foundation everything else builds on.
Products built on seshat
| seshat (this repo) | SeshatOS | SeshatCloud | |
|---|---|---|---|
| What it is | Go runtime + SDK + CLI/TUI + gRPC | Local-first desktop app and backend | Multi-tenant server and admin console |
| Stack | Go | Go + TypeScript/React/Electron | Go + TypeScript/React (+ a Python service for document intelligence) |
| License | Apache-2.0 | Apache-2.0 + Commons Clause (source-available) | Source-available (draft) |
| Who it's for | Developers embedding agents in their own apps | Individuals and small teams who self-host | Organizations that need central administration |
| Status | Stable, in production use | Under construction (chat-first desktop rebuild) | Server side solid, not yet a packaged offer |
Both products consume seshat through pkg/* only. seshat knows nothing about them.
The commercial activity around Seshat (AI consulting and integration, plus the products above) is presented at seshat-ai.com.
🤝 Contribution split
| If you want to... | Contribute to... |
|---|---|
| Improve execution speed, reduce latency, optimize the agent loop | seshat (Go) |
| Add a new LLM provider or tool | seshat (Go) |
| Expose new capabilities in the SDK or gRPC API | seshat (Go) |
| Improve the desktop app or local backend | SeshatOS |
| Work on organizations, IAM, or scheduled automation | SeshatCloud |
The engine is intentionally kept minimal and fast. If you need something from the SDK that is not exposed yet, open an issue and we will prioritize it.
📦 Installation
The full guide is on the website: Installation — seshat-ai.com. It covers the install script and what it does, its options, the Go toolchain, building from source and using Seshat as a library. The commands below are the short version.
| System | Command (copy, paste, run) | Needs |
|---|---|---|
| Linux (amd64, arm64) | curl -fsSL https://raw.githubusercontent.com/KPO-Tech/seshat-runtime/main/scripts/install.sh | bash |
curl or wget |
| macOS (Intel, Apple silicon) | the same command as Linux | curl |
| Windows (amd64, arm64) | irm https://raw.githubusercontent.com/KPO-Tech/seshat-runtime/main/scripts/install.ps1 | iex in PowerShell |
nothing, no administrator rights |
You do not need Go: the script downloads a ready-made binary. Afterwards the command is seshat on every system, and seshat update keeps it current (see Updating below).
Linux and macOS — one command, fully configured:
curl -fsSL https://raw.githubusercontent.com/KPO-Tech/seshat-runtime/main/scripts/install.sh | bash
Downloads the right binary for your platform, adds it to your PATH, and leaves the runtime directory (~/.config/seshat-cli/) ready. The DB and sessions are created on first run.
Options:
VERSION=v0.1.0 bash <(curl -fsSL ...) # pin a specific version
Windows (PowerShell) — one command, no administrator rights:
irm https://raw.githubusercontent.com/KPO-Tech/seshat-runtime/main/scripts/install.ps1 | iex
Downloads the Windows build (amd64 or arm64), checks it against SHA256SUMS.txt, installs seshat.exe into %LOCALAPPDATA%\Programs\seshat, adds that folder to your user PATH and installs ripgrep (winget, scoop or choco) when it is missing. Set $env:SESHAT_VERSION = "v1.9.0" before the command to pin a version, $env:SESHAT_INSTALL_DIR to choose the folder, $env:SESHAT_SKIP_RIPGREP = "1" to skip ripgrep.
Updating. The installed binary updates itself. When you start seshat in a terminal and a newer release exists, it says so and asks Update now? [Y]es / [l]ater / [s]kip this version. seshat update does the same on demand (--check only looks, --yes skips the question). The download is checked against the release's SHA256SUMS.txt before it replaces the binary, and the old binary stays in place if anything fails. The release is looked up at most once a day, with a 2-second limit; SESHAT_NO_UPDATE_CHECK=1 turns the offer off. Development builds and non-interactive runs (pipes, CI) are never asked. Re-running the install script also updates.
Session titles, offline (optional). By default the chat provider names each session after the first message. seshat title-model install (the installers offer it) adds a small local model instead, about 500 MB once, CPU only: titles take under a second, cost nothing and keep the first message on your machine. seshat title-model status|disable|enable|remove manage it, and the provider still names the session whenever the local model is missing or fails.
Everything lives in <runtime folder>/title-model/ (~/.config/seshat-cli/ on Linux, %APPDATA%\seshat-cli\ on Windows): the llama.cpp server, the model, a state.json and the server's server.log; seshat title-model remove deletes the folder. The server listens on the loopback address only, runs while seshat is open (about 600 MB of memory) and stops after ten idle minutes; if seshat is killed, the next run stops the server it left behind. SESHAT_TITLE_MODEL=1 makes the installers install it without asking.
Developers — Go toolchain:
# Install the CLI binary
go install github.com/KPO-Tech/seshat-runtime/tui/cmd/cli@latest
SDK — embed in your Go application:
go get github.com/KPO-Tech/seshat-runtime@latest
🔀 Three Ways to Use It
1. 💻 CLI — seshat
An AI agent in your terminal. Multi-provider, local-first, skills-aware. Guide: Using the CLI.
Install
# End users — full setup in one command:
curl -fsSL https://raw.githubusercontent.com/KPO-Tech/seshat-runtime/main/scripts/install.sh | bash
# Windows (PowerShell):
# irm https://raw.githubusercontent.com/KPO-Tech/seshat-runtime/main/scripts/install.ps1 | iex
# Developers — binary only via Go toolchain:
go install github.com/KPO-Tech/seshat-runtime/tui/cmd/cli@latest
Configure a provider
seshat config --provider anthropic --api-key sk-ant-...
seshat config --model anthropic:claude-sonnet-5-5
seshat config --print
Run
seshat chat # interactive TUI session
seshat chat --resume <session-id> # resume a specific session
seshat chat --continue # resume the most recent session
seshat run "list all TODO comments in this codebase" # one-shot task
seshat sessions list # browse past sessions
seshat version # print installed version
seshat help # full command reference
Sessions are persisted locally in SQLite. Skills are loaded from .seshat/skills/ in your project. The full tool set is available: file edits, sandboxed bash, web search, browser, MCP servers, sub-agents.
2. 🌐 gRPC Server
Run seshat as a gRPC service and drive the same runtime from any language. Reference: gRPC API.
# Development
ANTHROPIC_API_KEY=sk-ant-... go run ./cmd/grpc
# From build
ANTHROPIC_API_KEY=sk-ant-... ./bin/seshat-grpc
The server starts on 127.0.0.1:50051 and exposes the whole runtime through four services in pkg/grpc/proto/seshat.proto:
| Service | What it covers |
|---|---|
SeshatService |
server info, models and providers, skills, MCP servers, and sessions: create, list, search, delete |
SessionService |
a conversation: submit a turn (unary or streamed), its events, messages, state, tools, plans, interrupt, compact |
MemoryService |
the long-term memory graph: entities, observations, search, the context block |
WorkflowService |
validate, draft and run workflows |
A turn streams its events, and a tool that needs a decision asks the client over the same open stream (permission_request → RespondPermission, allow / allow_session / deny). An agent opened from another language is therefore supervised as closely as one in the terminal, and a session is described completely at creation: model, system prompt, tool set, working directory, permission mode and the limits of the agent.
Python
pip install ./python
import seshat
with seshat.connect() as client:
with client.create_session(
system_prompt_template="You review Go pull requests.",
tools=["read_file", "bash"],
working_dir="/srv/repo",
permission_mode="onRequest",
max_turns=12,
) as session:
for event in session.stream("review the staged diff",
on_permission=lambda request: "allow"):
if event.kind == "chunk":
print(event.text, end="")
Full guide: python/README.md. seshat.aio is the same API on an asyncio channel.
Other languages
The contract is one .proto: make proto regenerates the Go stubs and the Python ones together, and the same file generates a client for TypeScript, Java, Rust, or anything else with a gRPC implementation.
# TypeScript
npx grpc-tools --js_out=. --grpc_out=. pkg/grpc/proto/seshat.proto
One runtime. Every language.
3. 📦 Go SDK
Embed the full runtime in your own Go application. Reference: Go SDK, with the events and hooks and the integration guide.
go get github.com/KPO-Tech/seshat-runtime/pkg/sdk
import "github.com/KPO-Tech/seshat-runtime/pkg/sdk"
client, err := sdk.NewClient(&sdk.ClientConfig{
APIKey: os.Getenv("ANTHROPIC_API_KEY"),
Model: sdk.ModelIdentifier{Provider: "anthropic", Model: "claude-sonnet-5-5"},
})
if err != nil {
log.Fatal(err)
}
defer client.Close()
session, _ := client.CreateSession(ctx)
resp, _ := session.SubmitMessage(ctx, "Write a Go HTTP handler for /health")
fmt.Println(resp.Content)
📊 How Seshat Compares
| Feature | seshat | Claude Agent SDK | OpenAI Agents SDK | LangGraph | CrewAI |
|---|---|---|---|---|---|
| Language | Go | Python/TS | Python | Python | Python |
| Single binary (no deps) | ✅ | ❌ | ❌ | ❌ | ❌ |
| CLI included | ✅ | ❌ | ❌ | ❌ | ❌ |
| gRPC server (any language) | ✅ | ❌ | ❌ | ❌ | ❌ |
| Multi-provider | ✅ (15) | ❌ Claude only | ❌ OpenAI only | ✅ | ✅ |
| MCP client | ✅ | ✅ | ✅ | Partial | ❌ |
| Sandboxed bash (Landlock, Windows sidecar, microVM) | ✅ | ✅ | ❌ | ❌ | ❌ |
| Skills system | ✅ | ❌ | ❌ | ❌ | ❌ |
| Built-in RAG | ✅ | ❌ | ❌ | ❌ | ❌ |
| Browser automation | ✅ | ✅ | ❌ | ❌ | ❌ |
| Session persistence | ✅ | ❌ | ❌ | ✅ | ❌ |
| OTel tracing | ✅ | ❌ | ❌ | ✅ | ❌ |
| Open-source license | Apache 2.0 | MIT | MIT | MIT | Apache 2.0 |
✨ Capabilities
| Capability | Details |
|---|---|
| 🌍 Multi-provider | Anthropic, OpenAI, Gemini, Mistral, DeepSeek, Ollama, OpenRouter, Codex, MiniMax, Z.ai, OpenCode, Cloudflare Workers AI |
| 🛠️ 60+ built-in tools | File read/write/patch, bash (Landlock, Windows sidecar or microVM), web search, web fetch, browser (Playwright), grep/glob, LSP, sub-agents, RAG, tasks, memory, worktree, notebooks, image generation, TTS/STT |
| 🔌 MCP client | Universal MCP client: plug in any MCP server (GitHub, Postgres, Slack, Docker, Notion, ...) |
| ⚡ Skills | Markdown instruction files injected into the system prompt: encode your team's conventions and domain expertise |
| 🎯 Execution modes | execute (default), plan (review before act), pair_programming (collaborative) |
| 🔒 Permission engine | Per-tool deny rules, auto-mode LLM classifier, configurable per session (auto / acceptEdits / onRequest / bypass / never) |
| 💾 Session persistence | SQLite-backed multi-turn sessions, resumable across restarts |
| 📡 Streaming | Text chunks + structured runtime events (tool calls, plan events, permission requests, token usage) |
| 🧠 Long-context compaction | Automatic context compression when approaching the model's window (configurable threshold) |
| 📉 Observability | Prometheus metrics + OpenTelemetry tracing (OTLP gRPC export, no-op when endpoint not set) |
🗂️ Repository Structure
seshat/
├── cmd/
│ ├── cli/ ← seshat CLI entrypoint (TUI + one-shot commands)
│ └── grpc/ ← gRPC server entrypoint
├── pkg/ ← public API (safe to import from outside)
│ ├── sdk/ ← Go SDK: Client, sessions, streaming, callbacks
│ ├── types/ ← shared types: Message, ToolUse, TokenUsage, ...
│ ├── agent/ ← agent definitions, built-in registry
│ ├── providers/ ← LLM provider abstraction, routing, fallback
│ ├── mcp/ ← MCP client: stdio, SSE, HTTP transports
│ ├── rag/ ← chunking, embedding, hybrid vector search
│ ├── skills/ ← skill loading, frontmatter parsing, injection
│ ├── memory/ ← in-session state, compaction strategies
│ ├── web/ ← web search, fetch, browser (Playwright)
│ ├── storage/ ← artifact store: S3, local filesystem
│ ├── vector/ ← vector DB abstraction
│ ├── contract/ ← Tool interface, CallResult, registry
│ ├── auth/ ← provider auth abstraction, OAuth device flow
│ ├── workspace/ ← sandbox path resolution, workspace layout
│ ├── monitoring/ ← Prometheus metrics, OTel spans
│ ├── grpc/ ← proto definitions and generated code
│ └── config/ ← app-level config from env
└── internal/ ← private implementation (do not import directly)
SeshatOS, SeshatCloud and any third-party consumer must import
pkg/*only, neverinternal/*.
🌐 Supported Providers
| Provider ID | Service | Auth |
|---|---|---|
anthropic |
Anthropic | ANTHROPIC_API_KEY |
openai |
OpenAI | OPENAI_API_KEY |
gemini |
Google Gemini | GOOGLE_API_KEY |
mistral |
Mistral AI | MISTRAL_API_KEY |
deepseek |
DeepSeek | DEEPSEEK_API_KEY |
ollama |
Ollama (local) | none |
openrouter |
OpenRouter | OPENROUTER_API_KEY |
codex |
ChatGPT Pro (OAuth) | device-code flow |
minimax |
MiniMax | MINIMAX_API_KEY |
z-ai |
Z.ai | Z_AI_API_KEY |
opencode |
OpenCode Zen | OPENCODE_API_KEY |
Full model listings and capabilities: docs/providers.md.
🚀 Quick Start
# 1. Install
curl -fsSL https://raw.githubusercontent.com/KPO-Tech/seshat-runtime/main/scripts/install.sh | bash
# Reload your shell (or open a new terminal) if prompted, then:
# 2. Configure your provider
seshat config --provider anthropic --api-key sk-ant-...
seshat config --model anthropic:claude-sonnet-5-5
# 3. Start chatting
seshat chat # new session (opens TUI)
seshat chat --continue # resume last session
seshat chat --resume <session-id> # resume a specific session
seshat run "list all TODO comments in this codebase" # one-shot task
No API key? Use Ollama for free local inference:
seshat config --provider ollama --model ollama:llama3.2(requires Ollama running locally)
Developers building from source: see the Development section below.
The same steps are on seshat-ai.com: the Quick start (resuming a session, the shortcuts of the terminal interface), Configuration (the command line, the environment variables, the providers) and Your first agent (running a task, adding a skill, calling the runtime from your own code).
Seshat Runtime MCP questions
What is Seshat Runtime?
Seshat is an open-source Go agent runtime designed for governed, multi-provider, and self-hostable autonomous agent execution.
Can I embed Seshat in my own application?
Yes, you can embed the runtime inside a Go application or use the provided Go SDK and gRPC surfaces.
Does Seshat support different LLM providers?
Yes, it features multi-provider routing with support for over 15 LLM providers.