Newsletter

Koru: Our AGI?

Ande

05 Feb 2026 — 4 min read

Most people have now heard the word “AGI.” It gets used like a destination: build a mind that can do anything, and the future arrives.

But there’s a quieter truth hiding under the hype:

Powerful intelligence is already here—not as a single god-mind, but as tools that can write, reason, code, refactor, summarise, generate options, and iterate at speeds most humans can’t match.

The problem is not “can we generate?”

The problem is: how do we stop generation from becoming confident nonsense, ethical drift, or runaway momentum?

That’s what Koru is for.

Koru is not a model.

Koru is not a brand of “AI.”

Koru is a shape: a method for turning frontier-level capability into governed, auditable, human-steerable outcomes.

If “AGI” is the dream of an unconstrained universal mind, Koru is the counter-proposal:

Instead of chasing one apex intelligence, build a governed growth engine that can harness superhuman leverage safely—today.

That engine is already instantiated in Origin.

What Koru Is (in plain English)

Koru is a disciplined way to think and build that prevents the most common failure mode of powerful tools:

fluent certainty that isn’t true,
fast iteration that outruns governance,
outputs that can’t be checked,
momentum that becomes ideology.

Koru replaces “prompt → output → vibes” with a repeatable loop:

Anchor — name what must not be violated (truth, consent, safety, “unknown stays unknown”)
Unfurl — generate possibilities aggressively (this is where frontier tools shine)
Constrain — apply limits (physics, time, evidence, ethics, risk)
Converge — keep only what survives pressure
Integrate — store results as inspectable artifacts (specs, tests, plans—not just prose)
Return — audit against the anchor; detect drift and smuggled assumptions
Spiral again — rerun narrower and deeper at higher resolution

That’s Koru: governed growth by return.

What GSI Is (and why it’s part of Koru)

Koru’s “law layer” is GSI: Governed Structural Intelligence.

GSI is a simple demand:

If your output cannot be checked, it isn’t finished.

So GSI forces outputs into structure:

claims tethered to premises,
assumptions named,
constraints explicit,
failure modes visible,
tests or verification steps included.

Koru is the growth shape.

GSI is the truth-and-governance discipline inside it.

Together they let you use powerful tools without being used by them.

The Promise: Leapfrog, Don’t Start From Scratch

Yes, a reader could build their own Koru from first principles.

But that’s not the point.

The point is leapfrog.

We already assembled the engine.

You bring the target and the limits.

We lit the fuse—now you design controlled explosions:

explosive creativity and rapid iteration inside a bounded blast chamber,
strict governance and auditability outside it.

This is what modern capability is missing: a blast chamber.

Koru is that chamber.

Where to Find Koru

Koru is instantiated in the Origin repository:

Origin: https://github.com/default-user/Origin

This is the public anchor point: where the Koru engine lives, evolves, and can be run.

How to Use Koru in Origin (the practical path)

You are looking for one of three things inside Origin:

A documented workflow (README / docs)
A runnable entrypoint (CLI, script, Make target)
The core Koru loop definition (schemas / modules / templates)

Quick start: get the repo locally

git clone https://github.com/default-user/Origin.git

cd Origin

Find the Koru/GSI entry points

rg -n "Koru" .

rg -n "GSI|Governed Structural Intelligence" .

These searches will surface where Koru is described and how it’s run.

Find “how to run” commands

find . -maxdepth 3 -type f \( -name "README*" -o -name "Makefile" -o -name "package.json" -o -name "pyproject.toml" \)

Once you locate the entrypoint, you can run Koru repeatedly like a machine.

The Koru Control Panel (what

you

decide)

Koru is not “tell me what to do.”

Koru is “I choose the explosion.”

You set four dials:

1) Target

What are we exploding?

a product decision
a feature spec
a research question
a life plan
a codebase refactor

2) Blast radius

How far can results travel?

A simple scale works:

R0: ideas only
R1: drafts/plans only
R2: code/docs generated but not deployed
R3: deployment allowed with heavy checks
R4: real-world actuation (rare; normally forbidden without hardened governance)

3) Risk class

What happens if we’re wrong?

low → brainstorming
medium → personal planning
high → legal/medical/financial/security

4) Anchor

What must never be violated?

don’t lie
don’t harm
unknown stays unknown
consent beats momentum
no coercion

These are not vibes. They are enforceable boundaries.

The “Controlled Explosion” Workflow (what to do every time)

When you run Koru, you run this:

Write the anchor (5–12 invariants)
State the target
Set blast radius + risk class
Unfurl: generate 10–50 candidates
Constrain: apply your limits
Converge: select survivors
Integrate: produce one artifact (spec/checklist/tests/plan)
Return: audit for drift and smuggled assumptions
Spiral: rerun narrower and deeper

This loop is what turns “AI power” into “human-usable progress.”

Copy-Paste Starter Template

Use this exactly as written—inside Origin workflows, inside Claude Code/Codex sessions, or in your own notes:

ANCHOR (invariants)

TARGET (what are we exploding?)

BLAST RADIUS (R0–R4)

RISK CLASS

UNFURL (10–50 possibilities)

CONSTRAINTS

Hard:

Soft:

Unknowns:

Operational:

CONVERGE (survivors)

INTEGRATE (artifact)

(spec / checklist / tests / plan / decision memo)