SYNTHEOS
SYS.ONLINE

RUST-NATIVE AI INFRASTRUCTURE

MEMORY. SECURITY. CONTROL.

Rust-native infrastructure for autonomous AI agents. Hardware-backed secrets, persistent semantic memory, and a full agent gateway -- all in one coherent daemon stack.

HOW IT WORKS VIEW DAEMONS
RUST_NATIVE// ONNX_EMBEDDINGS// LIBSQL_STORAGE// FIDO2_YUBIKEY// TOKIO_AXUM// AES_256_GCM// ARGON2ID_KDF// ZERO_PLAINTEXT_SECRETS// KNOWLEDGE_GRAPHS// EPHEMERAL_BEARER// RUST_NATIVE// ONNX_EMBEDDINGS// LIBSQL_STORAGE// FIDO2_YUBIKEY// TOKIO_AXUM// AES_256_GCM// ARGON2ID_KDF// ZERO_PLAINTEXT_SECRETS// KNOWLEDGE_GRAPHS// EPHEMERAL_BEARER//
SYSTEM OVERVIEW // HOW THEY WORK TOGETHER

Three Daemons.
One System.

Every AI agent session flows through all three daemons in concert. Eidolon routes and controls. Engram remembers and recalls. Cred guards every secret. Together they turn isolated LLM calls into a coherent, stateful, secure agent infrastructure.

01 // EIDOLON -- Register & Route

Agent connects. Eidolon authenticates, assigns routes, allocates an Engram namespace, and configures capability limits.

$ curl $EIDOLON_URL/activity -d '{"action":"agent.online"}'
route: memory.* -> engram:ns-alpha
↓
02 // ENGRAM -- Recall & Learn

Agent searches past decisions, retrieves relevant context, stores new learnings. Every call builds on accumulated knowledge.

$ engram-cli search "deploy config" --top 3
[0.96] primary deployment server config
↓
03 // CRED -- Secure & Gate

Every secret access triggers a YubiKey HMAC challenge. Agents receive ephemeral bearer tokens only.

$ cred get github deploy-token --raw
✔ Ephemeral token issued [300s TTL]
↓
04 // LOOP -- Results Propagate

Task outcomes publish through Eidolon's event bus. Engram stores new learnings. The system self-documents every cycle.

$ curl $EIDOLON_URL/activity -d '{"action":"task.completed"}'
✔ event published + memory stored
03_EIDOLON // AGENT FLEET COMMAND
eidolon :: fleet control
-- agent fleet status --
$ eidolon agents --status
AGENT STATUS UPTIME LAST_TASK MEMORY_NS
claude-code ONLINE 4h 22m rewrite landing page ns-alpha
codex-win ONLINE 2h 08m update nginx config ns-beta
gemini-cli OFFLINE -- generate test fixtures ns-gamma
Active routes: 14 | Events/hr: 847 | Uptime: 99.2d
-- route configuration --
$ eidolon routes show claude-code
ROUTE TARGET POLICY
memory.* engram:ns-alpha read+write
secrets.* cred:ephemeral touch-required
tasks.* chiasm:claude read+write
events.publish axon:default all-events
context.assemble broca:claude read-only
$

The Nerve
Center.

Fleet orchestration. Hard security boundaries. Real-time control.

Eidolon turns individual AI agents into a coordinated fleet. It manages WHO can do WHAT -- routes requests to the right services, enforces hard namespace isolation, publishes real-time events, and keeps everything in sync. No agent can reach outside its assigned boundaries.

Isolation
Hard namespace boundaries per agent. Each agent reads and writes ONLY its own Engram namespace -- cross-agent memory leakage is structurally impossible.
Events
Every action publishes to Axon: agent.online, task.started, deploy.pushed, error.raised. Full audit trail, real-time fleet visibility.
Heartbeat
Soma module tracks every agent last-seen. Thymus enforces output quality rubrics per role. Dead agents detected in seconds.
01_ENGRAM // PERSISTENT MEMORY ENGINE

Total
Recall.

Every decision. Every context. Every session.

Engram is the brain of the agent stack. True continuity across sessions -- agents remember what happened yesterday, last week, across thousands of invocations. All inference runs locally via ONNX. No cloud. No data leakage. Knowledge graphs connect related memories so context compounds over time.

SEARCH
Semantic + BM25
EMBEDDINGS
ONNX Local
GRAPH
Knowledge Graph
STORAGE
libsql / Turso

Without Engram, every agent session starts from zero. With Engram, agents build on accumulated knowledge -- decisions, preferences, infrastructure state -- compounding across thousands of sessions.

KNOWLEDGE INGESTION

Engram doesn't just store facts -- it grows agent capabilities. When new documentation or codebases are ingested, agents develop new skills and deeper domain knowledge. A team that integrated an external API yesterday has agents that understand those patterns today.

engram :: memory ops
-- store a memory --
$ engram-cli store \
  --type decision \
  --content "Migrated auth service to token-based flow. Removed legacy session cookies." \
  --tags infra,servers,decision
✔ Stored [id=m_4f8a2c] embedding=384d latency=12ms
-- semantic search across all sessions --
$ engram-cli search "which server should I use" --top 3
Embedding query... [12ms]
Hybrid search (vec + BM25) [8ms]
[0.97] Migrated auth service to token-based flow...
[0.83] API gateway config: rate limits per service tier
[0.71] Deploy pipeline: staging validated before prod
-- knowledge graph traversal --
$ engram-cli graph traverse --from "auth-service" --depth 2
auth-service --[decision]--> "token-based flow adopted"
auth-service --[affects]--> api-gateway
auth-service --[tested-by]--> integration-suite
engram-daemon --[stores]--> agent-memories
engram-daemon --[uses]--> onnx-embeddings
Found 5 nodes, 5 edges [3ms]
$
02_CRED // HARDWARE ROOT OF TRUST

Zero.
Plaintext.
Secrets.

Agents never touch raw credentials. The cred daemon gates every request behind physical YubiKey presence -- HMAC challenge, Argon2id key derivation, AES-256-GCM decryption. Agents receive ephemeral bearer tokens only.

SECURITY CHAIN
Agent Request
↓
cred daemon
↓
YubiKey HMAC Challenge
↓
Argon2id KDF
↓
AES-256-GCM Decrypt
↓
Ephemeral Bearer Token
ENCRYPTION AES-256-GCM
KDF ARGON2ID
AUTH YUBIKEY FIDO2
AGENT ACCESS EPHEMERAL BEARER
PLAINTEXT AT REST ZERO
cred-daemon :: terminal
-- storing a new credential --
$ cred set cloudflare api-key
Enter value (hidden): ****
Waiting for YubiKey touch...
✔ Encrypted + stored. AES-256-GCM, slot 2.
-- agent retrieval via daemon --
$ cred get cloudflare api-key --raw
Waiting for YubiKey touch...
HMAC challenge OK // KDF: argon2id
✔ Decrypted via HMAC-SHA1
cf-api-*****-[REDACTED]
-- agent uses bearer token, not raw secret --
$ curl -s $ENGRAM_URL/activity \
  -H "Authorization: Bearer $(cred get engram api-key-claude --raw)" \
  -d '{"action":"task.completed"}'
Waiting for YubiKey touch...
{ "status": "ok", "token_ttl": 300, "issued_to": "claude-code" }
$
SUPPORTING DAEMONS // THE FULL STACK

Four Daemons.
Always Running.

Beyond the core triad, four supporting daemons handle event routing, context assembly, task tracking, and quality enforcement. Every agent action touches all of them.

04_AXON
Event Bus

High-throughput pub/sub connecting every daemon in the stack.

  • --Every agent action publishes structured events: agent.online, task.started, deploy.pushed, error.raised
  • --Webhooks, state changes, and cross-session signals over a single bus
  • --The nervous system that keeps the entire fleet synchronized in real time
06_LOOM
Context Assembly

Dynamic prompt generation engine -- assembles context on every agent invocation.

  • --Pulls from Engram memories, Chiasm tasks, and agent config to build coherent prompts
  • --Multi-step workflow orchestration -- breaks complex tasks into managed sequences
  • --NL action narration: agents explain what they are doing in real time
05_CHIASM
Task Tracking

Distributed state machine for task lifecycle -- nothing falls through the cracks.

  • --Prevents agent loop failures: agents stuck retrying the same action are detected and halted
  • --Maintains active checklists across sessions with full lifecycle state
  • --Tasks persist across agent restarts -- work survives crashes and interruptions
08_THYMUS
Quality Enforcement

Output quality rubric engine -- enforces standards across every agent role.

  • --18 async evaluation functions run against every significant output
  • --Per-role quality rules: different standards for code agents vs ops agents vs research agents
  • --Catches agent drift -- detects when agents start taking shortcuts or producing degraded work
DAEMON STACK // FULL SYSTEM ARCHITECTURE
SYNTHEOS DAEMON TOPOLOGY
AGENT
claude-code
AGENT
codex
AGENT
custom-n
GATEWAY
03_EIDOLON
routing + registration + heartbeat
MEMORY
01_ENGRAM
libsql + ONNX
SECRETS
02_CRED
YubiKey + AES-GCM
EVENTS
04_AXON
pub/sub bus
TASKS
05_CHIASM
NARRATION
06_BROCA
CONTEXT
07_LOOM
HEARTBEAT
08_SOMA
QUALITY
09_THYMUS
DAEMON REGISTRY
ID
NAME
FUNCTION
01
ENGRAM
Semantic memory engine. Hybrid search, ONNX embeddings, relational graphs. libsql storage.
02
CRED
YubiKey-backed credential vault. AES-256-GCM at rest, HMAC challenge unlock, ephemeral bearer tokens for agent access.
03
EIDOLON
Agent gateway and orchestration layer. Routes prompts, manages registration, enforces execution limits.
04
AXON
High-throughput inter-service pub/sub. Webhooks, state change events, cross-session signals.
05
CHIASM
Distributed state machine for task tracking. Prevents agent loop failures, maintains active checklists.
06
BROCA
Natural language action narration. Translates raw agent operations into human-readable status updates.
07
LOOM
Context assembly engine. Weaves Engram memories, Chiasm tasks, and agent config into coherent prompts per invocation.
08
SOMA
Agent heartbeat registry. Tracks last-seen timestamps, manages agent lifecycle, detects dead agents in seconds.
09
THYMUS
Output quality rubric engine. 18 async evaluation functions enforce per-role standards, catching agent drift and degraded work.
ZERO PLAINTEXT AT REST// HARDWARE KEY REQUIRED// EPHEMERAL BEARER TOKENS// LOCAL ONNX INFERENCE// NO CLOUD DEPENDENCY// AGENTS NEVER SEE SECRETS// RUST MEMORY SAFETY// ASYNC TOKIO RUNTIME// ZERO PLAINTEXT AT REST// HARDWARE KEY REQUIRED// EPHEMERAL BEARER TOKENS// LOCAL ONNX INFERENCE// NO CLOUD DEPENDENCY// AGENTS NEVER SEE SECRETS// RUST MEMORY SAFETY// ASYNC TOKIO RUNTIME//