KAI OS v0.3.1: first-run Evidence OS tour

[morning-verlu]

KAI OS v0.3.1 is live: https://github.com/morning-verlu/KAI/releases/tag/v0.3.1

This release adds the new first-run command:

curl -fsSL https://morning-verlu.github.io/KAI/install.sh | sh
export PATH="$HOME/.kaios/bin:$PATH"
kaios tour

kaios tour creates a disposable Git workspace, runs quickstart, makes a small code change, runs kaios review, and prints pointers to the generated review artifact, process trace, replayable capsule, process table, evidence summary, and recovery report.

Why this matters: the project is trying to make the core idea understandable in under a minute. KAI OS is not a chatbot wrapper; it is a local-first Evidence OS for agents: Agent = Process, Workflow = Scheduler, Tool = Syscall, Memory = Process state.

Feedback I would love:

• Does the OS metaphor make sense from the first run?
• Is kaios tour enough to understand the product without reading docs?
• What would make this useful for Kotlin/JVM teams evaluating agent runtime infrastructure?

Release notes: https://github.com/morning-verlu/KAI/blob/main/CHANGELOG.md
Docs: https://morning-verlu.github.io/KAI/

[morning-verlu]

KAI OS v0.3.1 now has a first-run Evidence OS tour:

curl -fsSL https://morning-verlu.github.io/KAI/install.sh | sh
export PATH="$HOME/.kaios/bin:$PATH"
kaios tour

The tour runs without an API key, creates a disposable Git repo, and produces the core Evidence OS artifacts: process table, Markdown review, trace JSON, replayable capsule, evidence summary, and recovery dry-run report.

I am looking for feedback on three things:

1. Does the Agent = Process / Workflow = Scheduler / Tool = Syscall model feel useful?
2. Would replayable run capsules help in PR review, support, or CI?
3. What would make kaios review valuable enough to run on a real Kotlin/JVM repo?

[morning-verlu]

Post-release update: KAI OS v0.3.1 now has two lower-friction ways to inspect the Evidence OS path.

No local Java/Gradle setup:

https://codespaces.new/morning-verlu/KAI?quickstart=1

No install at all:

https://github.com/morning-verlu/KAI/tree/main/examples/evidence-sample

The Evidence Sample includes a Markdown review artifact, kaios.process-trace/v1, kaios.run-capsule/v1, and kaios.review/v1 output from a disposable Kotlin repo. If you only skim those files, feedback is still useful here or through the lightweight Evidence feedback issue template:

https://github.com/morning-verlu/KAI/issues/new?template=evidence_feedback.yml

[morning-verlu]

Update: I added two concrete Evidence OS examples so the project is easier to evaluate without guessing from the README.

• JVM Service Review example: https://github.com/morning-verlu/KAI/tree/main/examples/jvm-service-review

  • creates a tiny Kotlin/JVM billing-service change
  • runs kaios review --json
  • produces Markdown review, process trace, replayable capsule, and kaios.review/v1 JSON

• Baseline Gate example: https://github.com/morning-verlu/KAI/tree/main/examples/baseline-gate

  • includes a known-good baseline capsule and a current changed capsule
  • kaios diff ... --check exits 1 because stable runtime behavior changed
  • includes normalized kaios.run-diff/v1 output and a GitHub Actions baseline gate template

These are meant to show the core idea more concretely: KAI OS is not a chatbot wrapper; it packages agent runs as local, replayable, CI-gateable evidence.

[morning-verlu]

Update: added a visual Evidence Artifact Map for the first-run product loop.

The short version:

Git change -> kaios review -> review.md + trace.json + capsule.json -> review/audit/baseline gate

The goal is to make the value clear before anyone installs a model provider or reads the full docs: agent work should leave runtime evidence that can be inspected, replayed offline, and gated in CI.

Useful links:

• Start here: https://github.com/morning-verlu/KAI/blob/main/START_HERE.md
• Evidence Sample: https://github.com/morning-verlu/KAI/tree/main/examples/evidence-sample
• JVM Service Review: https://github.com/morning-verlu/KAI/tree/main/examples/jvm-service-review
• Baseline Gate: https://github.com/morning-verlu/KAI/tree/main/examples/baseline-gate

The image is also available as a direct PNG for posts: https://morning-verlu.github.io/KAI/assets/kaios-evidence-map.png

[morning-verlu]

Update: KAI OS now has a direct Kotlin/JVM runtime API entrypoint, not only the CLI-first Evidence OS tour.

Kotlin API doc:

https://github.com/morning-verlu/KAI/blob/main/docs/KOTLIN_API.md

Runnable library example:

./gradlew -p examples/kotlin-runtime-api run

This example embeds the runtime model in Kotlin code:

• AgentSpec as a process definition
• WorkflowScheduler as a priority-aware DAG scheduler
• ToolRegistry as the syscall boundary
• ToolCapabilityGrant for permissioned tool access
• SessionMemoryStore with scoped memory
• LocalWorkerExecutorBackend(parallelism = 2) as a local worker simulation
• deterministic MockModelProvider, no API key required

Why this matters: KAI OS should be legible both as a CLI product path (kaios tour, kaios review, kaios evidence) and as an embeddable Kotlin/JVM Agent OS runtime for teams building their own agent infrastructure.

[morning-verlu]

Evidence Viewer update: KAI OS now has a no-install browser view of the checked-in evidence sample.

Open it here:
https://morning-verlu.github.io/KAI/evidence-viewer.html

It shows the core Evidence OS surface without requiring Java, Gradle, Docker, Codespaces, or an API key:

• process table for run-9c888ffe
• syscall ledger with tool permissions and redacted args
• capsule contract and deterministic offline replay status
• baseline gate behavior drift example
• links back to the underlying Markdown artifact, trace JSON, capsule JSON, and stable diff artifact

This should make the product easier to evaluate before installing: the question is not "does it chat?" but "does the agent run leave evidence another developer or CI job can inspect later?"

Feedback welcome: does this no-install viewer make the Evidence OS idea clearer than the README alone?

[morning-verlu]

June 17 maintainer update: the best next feedback is now much more concrete.

If you have 5 minutes and do not want to install anything, start with the Evidence Viewer:

https://morning-verlu.github.io/KAI/evidence-viewer.html

It shows the product surface directly: process table, syscall ledger, replayable capsule, baseline gate behavior drift, and links back to the raw artifacts.

Good next actions by role:

• Kotlin/JVM developer: read the Kotlin Runtime API and run ./gradlew -p examples/kotlin-runtime-api run.
  https://github.com/morning-verlu/KAI/blob/main/docs/KOTLIN_API.md
• OSS maintainer: skim the 5-minute evaluator checklist and say whether kaios review evidence would help PR review.
  https://github.com/morning-verlu/KAI/blob/main/docs/EVALUATE.md
• Docs/evidence contributor: [Good first issue]: Add a denied-syscall evidence walkthrough #15 is open for a denied-syscall walkthrough.
  [Good first issue]: Add a denied-syscall evidence walkthrough #15
• Kotlin API contributor: [Good first issue]: Add a Kotlin API recipe for custom tool capabilities #14 is open for a custom tool capability recipe.
  [Good first issue]: Add a Kotlin API recipe for custom tool capabilities #14
• Docker/CI tester: [Infrastructure]: Make Docker smoke faster and less dependent on package downloads #16 is open for full Docker smoke verification on a normal network.
  [Infrastructure]: Make Docker smoke faster and less dependent on package downloads #16

The live contributor board is here:

https://github.com/morning-verlu/KAI/blob/main/docs/CONTRIBUTOR_BOARD.md

The core question I want answered is still simple: does packaging agent work as local process evidence, replayable capsules, and CI-gateable traces solve a real pain for Kotlin/JVM teams?

[morning-verlu]

Kotlin/JVM feedback update: I opened a focused discussion for the runtime API shape and Evidence OS model.

Discussion:
#17

Kotlin/JVM evaluation path:
https://github.com/morning-verlu/KAI/blob/main/docs/KOTLIN_JVM_EVALUATION.md

The questions I most want answered are whether the API feels idiomatic Kotlin, whether Agent = Process / Workflow = Scheduler / Tool = Syscall is useful for JVM teams, and whether replayable capsules would help PR review or CI gates.