Set many models in concert
One model is a single sort; orchestration is the composed page. Jikji runs swarms that debate and revise, an evolved coordinator that learns which model to route each turn to, and delegation that fans work out to sub-agents and peers.
Provider diversity is configuration, not a guarantee: a meaningful council requires genuinely distinct model families and valid credentials.
Swarms that debate, then a gated synthesis
Several models answer the same question, critique each other across rounds, and a synthesizer writes the final answer — optionally verified before it ships.
Debate & synthesize
Participants open with an answer each, then run bounded critique-and-revise rounds. A synthesizer composes the result; with verification on, a panel judges ACCEPT or REVISE and re-synthesizes on a majority REVISE.
Iterate to a bar
Drive a single model through repeated improve-and-check rounds until a quality bar or a step bound is met — useful for drafting, refactoring, and self-correction.
Compare candidates
Run the same task across several models or settings and compare the candidates side by side, so routing and provider choices rest on evidence, not guesswork.
Call a swarm as a tool — participants debate, then a verifier panel gates the result:
{ "tool": "agent.swarm", "args": { "question": "Design a rate limiter for the public API.", "participants": [ { "name": "architect", "model": "glm-5.1" }, { "name": "skeptic", "model": "deepseek-v4-flash:cloud" } ], "rounds": 2, "verify": true } }
A coordinator that learns the routing
Most "multi-agent" systems run a fixed script. The trinity coordinator runs a learned policy over the live state of a run — which model, in which role, on this turn. It is a policy you evolve and enable; the ensemble's default is the diverse verifier-gated panel.
A heterogeneous pool of agents is driven through a thinker / worker / verifier loop. Each turn the coordinator selects which agent acts and in which role, choosing the strongest fit for the current state of the task.
The selection policy is engineered over observable features — turn index, whether a plan exists, the last verdict, revise count, and task signals — and trained with a separable CMA-ES evolution strategy, then saved and served when you enable it. The result is adaptive routing, not a hard-coded schedule.
Coordination composes with the loop's verify-revise gate and ensemble synthesis, so multiple models contribute and a verifier holds the bar before an answer is returned.
A trinity.oracle tool runs a drift-consistency check — auditing whether a run stayed consistent with its goal, plan, and evidence. It's a self-audit any agent can invoke to catch a run that has quietly wandered off task.
Routing strategies are configurable per model group:
typebackbone: model_groups: premium: { providers: [deepseek-v4-pro], strategy: first_available } fallback: { providers: [glm-5.1, ollama-cloud, echo], strategy: failover }
Orchestration policy can evolve; quality still has to be measured
The coordinator, verifier, and RHO-inspired optimizer are separate mechanisms. A proposal that passes admission is safe to evaluate, not proven better.
Mechanical admission first
Dominated, drifted, or mechanically worse harness updates are rejected before a model preference can break a true tie.
Human release gate
An admissible directive is filed as pending approval. An operator reviews it before additive, capped injection into later runs.
Held-out comparison
Baseline and modified harnesses need the same task set, environment, scorer, and attributed metrics. Null or negative lift means reject the directive.
From sub-agents to peers across the network
Delegate to sub-agents
A delegate action hands a bounded sub-task to a child agent. Spawns are idempotent — keyed by (parent, request_key) so a retry never double-spawns — and carry a task-scoped role. A supervisor tracks children, harvests their results back into the parent's trace, and a scorecard audits the outcomes.
A2A federation
The agent-to-agent protocol covers task create / send / get / cancel plus an agent registry with heartbeat. Use it for explicitly configured, tenant-scoped peers; cross-tenant federation is not presented as a supported security boundary.
Collaboration memory
The galley workspace holds shared records, delegated tasks, and conversation intent across sessions, with a TTL-based lease manager that claims tasks and recovers orphaned ones.
Open agent protocols
Beyond A2A, Jikji speaks MCP and ACP over stdio for local peers, and coordinates multi-node dispatch over gRPC — so orchestration is never locked to one runtime.
Plans as dependency graphs
taskgraph.run executes a whole plan: tasks with depends_on edges each run as a durable sub-agent once their dependencies complete. Tasks in the same wave run concurrently — unless they touch the same file, in which case they are serialized — and the graph is validated up front, so a cycle is rejected before anything spawns.
Turn a session into a service — often without code
What you build in a chat is the product. Jikji can serve a primed session as a model, filter its output with Lua, expose your ontology, and run it on a schedule — so a new service-agent is configuration, not a codebase.
A session becomes a model
Register a primed session — its context captured as a prompt-cached prefix — and it appears in /v1/models, callable immediately as a model id. The expensive priming is a cache hit on every call, so the context is preserved cheaply. No new code, no redeploy.
Filter responses with Lua
A fail-closed Lua content filter screens and reshapes what passes through — redact, rewrite, or gate a response before it reaches the caller — with opt-in, allowlisted HTTP for enrichment.
Serve the ontology
Expose the native knowledge graph as a queryable service, so SPARQL and semantic search are available to callers — not just to the agent that built it.
Run it on a schedule
The almanac scheduler drives cron and interval jobs — a nightly ontology refresh, a periodic report, a recurring check — with no external scheduler to wire up.
Meet users on their channels
Serve the same agent over messaging channels: an inbound message becomes a run and the reply goes back out, with per-chat tool scopes, persistent per-chat memory, allowlists, and rate limits. A Telegram adapter ships today, and the adapter interface is built for more — Slack and beyond — alongside signed inbound webhooks.
Agents publish their own surfaces
An agent can publish a live UI with ui.render — a declarative table or chart serves immediately (server-rendered, no agent script runs) — or an API at /svc/{tenant}/{name} with service.publish: a static body, a sandboxed Lua handler, or a goal template where each request drives a durable agent run. Anything that runs code is published pending and serves only after an operator approves it.
Tools without borders
A tool call doesn't have to run where the agent is thinking. Tools execute on remote nodes chosen by capability and placement, reachable over relay tunnels — so a single run can reach across machines, clouds, regions, and operating systems, with a durable shared catalog, per-node circuit breakers, and failover.