Si SISAGA 硅仙人

Agent-native language / Agent civilization protocol

SISAGA turns intent into verifiable products.

SISAGA is an Agent-native language, I2P protocol compiler, and I2A accepted-completion system: it compiles human intent into verifiable, reusable, portable product-delivery contracts.

Inspect the first run Read the whitepaper brief

No magic without evidence. No autonomy without permission. No reward without contribution. No civilization without memory. No creation without contract. No agent collaboration without leases.

Intent Policy Agent IR Runtime Evidence Verifier Trace Memory Contribution Reward

Whitepaper Brief

Not another agent framework. A work protocol above them.

Human programming languages build software. Harnesses run agents. Agents do the work. Platforms host the work. SISAGA defines the contract around the work so it can be executed, inspected, compared, repeated, and rewarded.

Its first job is practical: turn a human-readable .sisa manifest into Agent IR, run allowed verification, and produce evidence files a human can inspect.

Architecture Channel

A dedicated architecture reference for the protocol.

SISAGA's long-term performance path is benchmark-driven synthesis: Agents express correctness and performance contracts, generate multiple implementations, target strong backends, profile them, and keep the winning evidence.

Open technical architecture

I2P Contract Language

Thin language, thick protocol.

V0.1.3-clean keeps V0.1.2 as the kernel: real intent first, smallest runnable accepted loop first, finite evidence, token thrift, peer ROI, product before artifacts, token fuse, and a short handoff. Later failed branches above V0.1.2 are not active doctrine.

SSS is now a separate branch for swarm sourcing. SISAGA Core keeps building the I2P language, contract, evidence, verifier, and gate foundation that SSS consumes.

Deep Thought Channel

Trend intelligence becomes next-version strategy.

After each Frontier Radar round and GPT Pro strategic dialogue, SISAGA records a language-separated Deep Thought note: what changed in the AI frontier, what it means for SISAGA, and which Next version should absorb the decision.

Open Deep Thought

Actual Difference

Where SISAGA sits

Layer What it does SISAGA difference
Python / Rust / Go / TS Implement programs, tools, services, runtimes. Describes the task contract around the code work.
Harness Engineering Wires models, prompts, tools, memory, retries, approvals. Provides a portable work order a harness can execute.
Agent The worker or reasoning process that performs actions. Defines what the worker may do and how it proves completion.
OpenClaw-like Platforms Provide workspace, tools, skills, runtime, sessions. Can consume or emit SISAGA contracts and evidence.
MCP / A2A / Skills Connect tools, agents, and reusable capabilities. Declares, governs, and records their use inside a task.

Collision Map

SISAGA wins by choosing the right layer.

The agent world already has languages, runtimes, tool protocols, coding platforms, workflow specs, and observability. SISAGA should not fight them. It should become the portable work contract that they can all read, execute, audit, and produce evidence for.

01

Human programming languages

They implement software and runtimes.

SISAGA defines the work contract around implementation.
02

Prompt and LLM DSLs

They structure model calls, prompt logic, schemas, and generation.

SISAGA governs autonomous tasks, permissions, evidence, and repeatability.
03

Agent runtimes and frameworks

They orchestrate agents, state, tools, retries, and execution graphs.

SISAGA supplies a runner-neutral manifest and Agent IR.
04

Coding agents and platforms

They provide the worker, workspace, session, tools, and UI.

SISAGA becomes the portable job order plus proof package.
05

MCP, A2A, tools, and skills

They connect agents to tools, services, other agents, and reusable abilities.

SISAGA records which capabilities were allowed, used, and verified.
06

Project instructions and memory

They tell an agent what a repo or workspace expects.

SISAGA binds instructions to one concrete task with traceable boundaries.
07

Workflow specs and low-code plans

They describe flows, nodes, roles, and repeated procedures.

SISAGA adds permission, evidence, contribution, and audit semantics.
08

Observability and evaluation

They measure behavior, traces, quality, and regressions.

SISAGA makes evidence a required artifact, not an afterthought dashboard.
09

Policy, sandbox, and security

They enforce what an agent can access or change.

SISAGA declares the requested permissions before execution and records the result.
10

Contribution and reputation systems

They reward value after work is accepted.

SISAGA creates the contribution manifest that future rewards can trust.

Complete Vision

SISAGA 1.0 turns agent help into accountable autonomous work.

Version 1.0 is not just a CLI milestone. It is the first stable standard for describing a task, granting safe autonomy, proving the result, and carrying the contribution record across tools and teams.

Macro shift

From chat transcript to work protocol

SISAGA 1.0 should move agent collaboration from vague conversation into inspectable work orders: what was asked, what was allowed, what happened, and why the result can be trusted.

For beginners

A visible contract for asking agents to do real work

A non-programmer can see the goal, boundaries, steps, files, results, and evidence without needing to understand the whole codebase or agent stack.

For expert builders

Portable delegation with audit hooks

Senior engineers can encode standards, approvals, verifiers, skills, and expected artifacts once, then run them across different harnesses and agents.

For teams

Issue to evidence bundle

A team can attach a SISAGA manifest to a ticket, receive a trace, review proof, compare runs, and decide with less guesswork.

For open collaboration

A substrate for skill civilization

Developers can publish task patterns, skills, benchmarks, and contribution manifests so value is visible before reputation or rewards are argued about.

1.0 must ship

Small enough to build, big enough to matter.

  • Stable .sisa manifest grammar and Agent IR schema.
  • Policy kernel for declared permissions, approvals, and execution boundaries.
  • Runner adapters for local CLI, coding agents, MCP/A2A capabilities, and CI.
  • Trace, verification, evidence, and contribution manifest as standard artifacts.
  • A public skill/workflow registry with benchmarks and example proof packages.

Real Experience

What SISAGA feels like for beginners and experts.

The point is not a new syntax for its own sake. The point is that agent work becomes easier to request, safer to delegate, and clearer to verify.

New developer

From opaque assistance to inspectable work

The main change is clarity: an agent task becomes a structured work order with visible goals, boundaries, checks, and evidence.

Workflow area Without SISAGA With SISAGA
Asking for work

The request is repeated across chat turns, and intent can drift.

The desired outcome, limits, and acceptance checks are captured in one task contract.

Trusting the result

Only the final answer is visible, with limited evidence of what changed.

Touched files, checks, status, summary, and human-readable evidence are visible.

Staying safe

The boundary between allowed and unsafe actions is unclear.

Permissions are declared before work, and the run records which capabilities were used.

Reusing success

A useful result is difficult to repeat because it remains embedded in a conversation.

A useful task pattern can become a reusable manifest or skill path.

Experienced engineer

From prompt delegation to auditable contracts

The biggest change is operational: expertise becomes encoded as reusable contracts, policy gates, verifiers, and evidence artifacts.

Workflow area Without SISAGA With SISAGA
Asking for work

Scope, tools, constraints, and acceptance criteria live in prompts or informal team knowledge.

Scope, policies, tools, artifacts, and checks live in a portable task contract.

Trusting the result

Review requires reconstructing the agent's actions from logs, diffs, and conversation.

Trace, verifier output, evidence files, and run metadata are standard outputs.

Staying safe

Policy is scattered across prompts, harness code, repo docs, and human review.

Policy becomes an explicit pre-run contract and enforceable runtime boundary.

Reusing success

A strong workflow is hard to move between agents, teams, and harnesses.

Validated workflows become portable skills with benchmarks and contribution records.

Efficiency & Quality Benchmark

Hard claims must be earned by controlled comparisons.

The numbers below are working targets and hypotheses until SISAGA publishes an official A/B benchmark. The standard is simple: same tasks, same models, same repositories, different workflow layer.

Evidence status Not yet measured on an official SISAGA benchmark.

v1.0 should prove impact with real issues, accepted PRs, verifier output, cost logs, review records, and complete evidence bundles.

Scenario Early target Mature target
Repetitive code tasks, scaffolding, test fill-in 2x - 4x, to be tested 5x - 10x, only if benchmarks confirm it
Real issue fixes and multi-file bugs 1.5x - 3x, to be tested 3x - 6x, measured against accepted PRs
Small or medium feature from requirement to PR 1.5x - 3x, to be tested 4x - 8x, with stable contracts and reusable skills
Large architecture work or complex refactor 1.1x - 2x, often limited by review depth 2x - 4x, if verifier coverage is strong
High-risk production change Not necessarily faster More auditable, easier to review, safer to roll back

Quality indicators

The quality claim is not just fewer bugs.

Measure validation omissions, context misunderstanding, review rework, regression count, human intervention count, evidence completeness, rollback time, and task reproducibility.

A/B design

Compare against direct agent use.

Run the same 50 real issues twice: direct Agent/Codex use versus SISAGA contract plus the same Agent/Codex stack. Compare accepted PR rate, completion time, review cycles, regressions, cost, and evidence quality.

v1.0 credibility gate

A serious pilot needs measured deltas.

The first strong target is 40%+ less time, 30%+ less review rework, 50%+ fewer validation omissions, and 20%+ higher accepted PR rate on the benchmark set.

First Runnable Manifest

The first fire is already inspectable.

The prototype compiles examples/hello.sisa into Agent IR, runs verification, then writes the evidence bundle. 

sisa run examples/hello.sisa

SISAGA is the task language and protocol. The current V0.1.5 accepted-preview keeps adaptive Prime swarm, protocol, schema, doctor, runtime, and release-gate evidence as implementation/verifier-lane proof.

Generated artifacts

  • agent-ir.jsonmachine-readable task contract
  • sico.jsonportable contract object
  • trace.jsontimeline of execution events
  • verification.jsoncommand results and pass/fail state
  • rollback.jsonrollback decision and recovery steps
  • policy.jsonpermission and effect checks
  • evidence.index.jsonmachine-readable evidence index
  • evidence.mdhuman-readable proof bundle
  • contribution.manifest.yamlfuture contribution record seed

Work Traces

Every serious claim should leave a trail.

  1. Compile

    .sisa manifest compiled into Agent IR.

  2. Policy Check

    V0.1.5 treats serious engineering as an adaptive routed contract: keep simple work light, classify the route, freeze non-goals and protected boundaries, record actual agent topology, disclose degraded mode, and preserve V0.1.2 hygiene.

  3. Verify

    python --version executed successfully with exit code 0.

  4. Evidence

    Run status, stdout, artifacts, and contribution seed written to disk.

Roadmap

From runnable manifest to civilization protocol.

The build path starts with a small inspectable runner, then expands into a portable protocol that other agents, harnesses, tools, and teams can trust.

v0.1

Runnable Manifest

Compile, run, trace, verify, and produce evidence.

v0.2

Policy Kernel

Turn declared permissions into enforced runtime boundaries.

v0.3

Adapter Layer

Connect MCP, AGENTS.md, skills, GitHub, and agent runtimes.

v0.4

Skill Civilization

Package reusable agent workflows with scores and benchmarks.

v0.5

Proof of Contribution

Record verified impact before reputation or rewards.

v1.0

Civilization Protocol

Stable IR, governance, evidence, adapters, and public benchmarks.

v1.1+

Global Ecosystem

Open adapters, verified skills, conformance tests, examples, and contribution manifests for global developers.

Spark Log

The living memory of the project.

spark.md is append-only. It records naming, positioning, product principles, implementation sparks, and rules for future agents. It is not the spec; it is the source of ideas that later become spec.

Current version
V0.0.0.41
Total updates
41
Rule
Never delete history. Add newer refinements instead.
Open Spark Page