Enterprise agent runtime · CGO-disabled Go release · GPL default

Jikji

The enterprise agent platform, set in metal type.

Jikji is a modular agent framework built in Go — a deterministic agent loop, durable orchestration state, adaptive multi-model coordination, and built-in governance. Release artifacts are built with CGO disabled; Linux amd64 is the currently native-qualified target.

Get Started Jikji Labs on GitHub Licensing

The Name

Named after the world's first movable metal type book

Jikji (직지심체요절) was printed in Korea in 1377 — the oldest surviving book printed with movable metal type, decades before Gutenberg. Movable type changed publishing the same way Jikji aims to change agents: composable pieces, set precisely, producing reliable output at scale.

Every module carries a letterpress name — the foundry casts the runtime, typebackbone faces the models, sorts are the tools, the compositor sets sessions, the forme locks the agent loop, and the press serves it to the world. Even the default port is 1377.

直指

EST. 1377

Jikjisimcheyojeol — the oldest extant book printed with movable metal type. UNESCO Memory of the World.

Proof, not a product slide

The examples are executable contracts for how Jikji behaves.

The repository ships runnable scenarios, production configuration, worked artifacts, and guarded live-provider checks. They document the path from a local echo run to a five-vendor council, a durable worker, or a hardened multi-tenant deployment. Claims that depend on a provider or environment are labelled as such.

Open the example ledger

Live evidence

agent-cli-backbone

A documented qualification path connects a coding CLI to a cross-vendor council over HTTP MCP, then records candidate and verifier stages for inspection.

Worked artifact

trinity-council

Independent answers, synthesis, and an adversarial ACCEPT/REVISE panel with the result preserved for inspection.

Deterministic

dispatch-queue-worker

Durable claim, lease, completion, and restart behavior demonstrated without relying on a model's opinion.

Operator path

production-hardening

Auth, TLS, policy, audit, redaction, backups, readiness, and observability assembled as a fail-closed deployment checklist.

Why Jikji

What makes it different from other agent frameworks

Most agent frameworks are Python or Node.js/TypeScript libraries glued to a vector DB, with opaque loops and governance bolted on later. Jikji is built like infrastructure from day one.

CGO-disabled Go releases, explicit host boundaries

The base release has no Python or Node.js runtime dependency. We cross-build six OS and architecture artifacts; native release qualification currently covers Linux amd64. Optional tools and host isolation retain platform-specific requirements.

See the architecture →

A deterministic, recoverable agent loop

The forme loop models every step as explicit actions and observations — with checkpointing and recovery built into the engine. Agent runs are replayable and auditable, not opaque chains that vanish on crash.

Inside the loop →

Adaptive multi-model orchestration

Run a swarm of models that debate and revise, gate the synthesis behind a verifier panel, and let the trinity coordinator learn which model to route each turn to — an evolved policy, not a fixed schedule.

How orchestration works →

Memory that learns, context that fits

The plate memory plane extracts facts, consolidates them in background "dreaming" passes, and serves hybrid recall. Context compaction and a model-promotion ladder keep long runs inside the window.

Memory & data →

Governance built in, not bolted on

Multi-tenancy, scoped API keys, RBAC, a dynamic policy filter chain with approval gates, structured audit, and PII/secret redaction — all in the core, with a vault for credentials and OAuth provider wiring.

Enterprise & security →

Open protocols, no lock-in

Serves an OpenAI-compatible API and speaks MCP (server and client), ACP, and A2A for agent-to-agent collaboration. Works with OpenAI-, Anthropic-, Ollama-, and GLM/Z.AI-compatible backends.

Protocols & surfaces →

Explore the platform

Seven planes, one press

Each plane owns one concern behind a strict boundary. Follow any of them into the detail.

Architecture

A print shop of composable modules, deployment shapes from one process to a grid, galley-backed storage, and the binaries that run it.

Agent loop

The deterministic forme loop — checkpoints and resume, Lua hooks, verify-revise synthesis, goal-driven runs, and a self-improving harness.

Tools

A broad built-in catalog — files, shell, a DOM-extracting browser, SQL, ontology — run under a sandbox, over MCP, or on remote nodes, plus Lua/Python functions as tools.

Orchestration

Multi-model swarms, the evolved trinity coordinator, delegation to sub-agents, and A2A federation across peers.

Memory & data

Cognitive memory with dreaming, hybrid recall, context and token optimization, and SQLite/PostgreSQL/MySQL backends.

Ontology engine

A native engine that builds knowledge graphs from a corpus and serves them with in-process SPARQL — an ontology over your data, with no external triple store.

Enterprise & security

Tenancy, RBAC and the policy plane, vault and OAuth, OpenTelemetry tracing, usage limits, redaction, injection defense, and robustness.

CGO-disabled build targets

primary server binary

open protocol surfaces

SQL backends

site locales with English fallback

1377

the default port, and the year

Interoperability

Speaks every protocol that matters

OpenAI-compatible API

Drop-in /v1/chat/completions, models, embeddings, runs, and sessions — point existing clients at Jikji.

MCP

Model Context Protocol server and client over stdio — consume MCP tools or expose Jikji as one.

ACP

Agent Communication Protocol over stdio for local process-based agent peers.

A2A

Agent-to-agent collaboration — task dispatch, delegation, and result harvesting between agents.

Operator tooling

jikjictl covers credentials and vault, RBAC, policy, audit queries, tracing, usage, and a marketplace — plus a separate web dashboard that never stores keys server-side.

Terminal-native

Interactive TUI chat, single-prompt mode, JSONL event streams for automation, and an MCP-shaped JSON-RPC mode — agents you can pipe.

Tested like infrastructure

A deterministic make verify gate plus guarded live smoke tests against real providers. Benchmark, fuzz, property, and concurrency tests throughout the codebase.

Get Started

Running in under a minute

# start the server (default port 1377 — yes, that 1377)
go run ./cmd/jikji serve --config config.example.yaml

# check your local environment
go run ./cmd/jikji doctor

# open the interactive chat TUI
go run ./cmd/jikjictl chat --mode tui

# or call the OpenAI-compatible API
curl -X POST http://127.0.0.1:1377/v1/chat/completions \
-H 'Content-Type: application/json' \
-d '{"model":"jikji-echo","messages":[{"role":"user","content":"hello"}]}'

Jikji is under active pre-1.0 development. APIs and module boundaries may change. Review the repository's release evidence, security policy, and known limitations before production use.