Si SISAGA 硅仙人

Technical Architecture

Agent-native language above the software production chain.

SISAGA should be judged by how well it organizes agentic software work: intent, constraints, permissions, verification, collaboration, evidence, cost, rollback, and contribution.

Back to homepage

Layered Stack

Four layers, one work contract.

The architecture starts with verifiable fundamentals: deterministic runtime behavior first, then portable IR, then a human-friendly language, then a global skill ecosystem.

L0

Deterministic Kernel

Tool calls, permission checks, task DAGs, sandboxing, budgets, trace logging, failures, retries, rollback, and recovery policies. Agents may be probabilistic; the kernel must be deterministic and auditable.

L1

Agent IR

A machine-readable representation of goals, context, effects, capabilities, success contracts, verifier requirements, risk, budget, approvals, artifacts, and rollback plans.

L2

Human-Writable Language

The .sisa surface should be closer to intent than Python, stronger than YAML, and more verifiable than a prompt. It describes what work means, not how to write every loop.

L3

Skill Ecosystem

Reusable agent workflows become installable skills with declared inputs, outputs, permissions, guarantees, benchmarks, traces, and contribution records.

Compiler Flow

From intent to evidence bundle.

AgentLang source
Parser / Compiler
Typed Agent IR
Policy Checker
Planner
Tool / Runtime Scheduler
Verifier Stack
Evidence Bundle
Human / CI / Deploy
human-readable .sisa
  -> parser / compiler
  -> typed Agent IR
  -> policy and effect checker
  -> planner and scheduler
  -> tools, agents, shell, browser, git, CI
  -> verifier stack
  -> trace + evidence bundle + rollback plan
  -> human review / CI / deploy

Project Mesh

I2P Swarm Contract Profile sits above A2A and MCP.

A2A can move tasks and artifacts between agents. MCP can expose tools. SISAGA defines the project contract, work packages, capability leases, evidence, verifier quorum, rollback, and contribution records that make multi-agent engineering auditable. 

Project Contract
  -> Work Package
  -> Agent Passport
  -> Capability Lease
  -> Isolated Workspace / Sandbox Profile
  -> Artifact Envelope
  -> Evidence Bundle
  -> Verifier Quorum
  -> Merge / Rollback Decision
  -> Contribution Record

SSS Branch

Swarm sourcing is a branch above the Core contract layer.

SSS uses SISAGA contracts, leases, artifacts, evidence, verifier quorum, and contribution records, but it evolves in its own folder and version line. Core stays focused on the I2P language and protocol foundation. 

Work Offer
  -> Agent Bid
  -> Capability Lease
  -> Crowd Submission
  -> Triage Queue
  -> Verifier Quorum
  -> Merge Queue
  -> Anti-Cheat Report
  -> Settlement Preview
  -> Contribution Record

Implementation Strategy

Protocol first, implementation second.

SISAGA is the language and protocol. The V0.0.0.20 preview is a Python bootstrap runner; the long-term hard kernel should move toward Rust after IR, SICO, SAGA, policy, evidence, and benchmark semantics stabilize.

Python bootstrap

Fast iteration for the runner, evals, benchmark analysis, Agent glue, trace analysis, and early dogfooding.

Rust hard kernel

Parser, compiler, runtime, policy checker, capability boundaries, trace recorder, verifier kernel, CLI, and WASM host.

TypeScript surfaces

Website, IDE, dashboard, trace viewer, workflow UI, SDKs, and developer-facing integration tools.

WASM and minimal assembly

WASM is the plugin isolation boundary. Assembly is only for tiny low-level glue, never the default implementation layer.

First-Class Citizens

The missing semantics become language objects.

Intent and success contracts

Goals, invariants, acceptance checks, and business constraints become executable and verifiable instead of living only in prompts or docs.

Effects and capabilities

Every action declares effects such as fs.write, shell.run, browser.click, network.fetch, db.write, money.spend, or email.send, then the runtime enforces capability boundaries.

Verifier stack

Cheap deterministic checks run first: parse, typecheck, lint, unit tests, static analysis. Expensive model review, red team, and human approval happen only where risk requires them.

Evidence types

Claims, patches, plans, approvals, and deployments should carry evidence, confidence, risk, and provenance so agents cannot casually treat guesses as verified work.

Rollback and recovery

Failure is normal in agent work. The language must express retry, rollback, escalation, blocked deployment, human approval, and recovery notes as part of the task.

Context as a resource

Context selection, exclusion, memory, pinned invariants, summaries, and provenance should be explicit so long context becomes a controlled resource, not a dumping ground.

Post-1.0 Ecosystem

Open ecosystem development after v1.0.

The ecosystem begins after v1.0: global developers can build adapters, verified skills, benchmarks, examples, policy packs, verifier plugins, and contribution records.

Adapters

Codex, OpenAI Agents SDK, LangGraph-like runtimes, MCP tools, A2A agents, GitHub, CI, browsers, databases, and local shells.

Verified Skills

Installable task packages with inputs, outputs, permissions, risk level, evals, traces, and success rates.

Conformance

Reference runner, public test suites, protocol surface registry, normalized diffs, migration reports, release gates, and evidence-bundle validation.

Contribution

Accepted work turns into contribution manifests that can later power reputation, rewards, and governance.