# Gnosh.ai – a super intelligent AI harness that thinks in Go

> Source: <https://gnosh.ai>
> Published: 2026-10-30 18:26:49+00:00

A coding agent that thinks, plans, and remembers in Gno.

[Gnosh](https://github.com/gnosh-ai/gnosh) runs the [Gno](https://github.com/gnolang/gno) VM in the AI harness. The agent keeps its goals, what it found and the facts you gave it in `mem`, kept in Gno on your disk, and a new session starts with what is still open and the newest facts, so it picks up where the last one stopped.

Underneath, it is a security-first fork of Charm's [Crush](https://github.com/charmbracelet/crush): any model, hosted or on your own machine, and nothing phones home unless you turn it on.

Built from source, with Go 1.27 or newer:

```
git clone https://github.com/gnosh-ai/gnosh
cd gnosh && go build -o gnosh .
mkdir -p ~/.local/bin
install -m 755 gnosh ~/.local/bin/gnosh
```

The code and its issues are on [GitHub](https://github.com/gnosh-ai/gnosh); a star there helps others find it.

Run `gnosh` in a project and press ctrl+l to pick a hosted one. For a model on your own machine, add it in `~/.config/gnosh/gnoshrc`:

```
provider add local --type llamacpp --base-url "http://127.0.0.1:8080"
# a local model can take minutes to read a long prompt
option request-timeout 900
```

youA client retries a failed request with exponential backoff: it waits 200 ms before the first retry, doubles the wait each time, and never waits more than 30 s. How long after the first failure does the 10th retry go out?

The agent works it out in the session's scratch machine instead of adding it up in its head, and answers "111 s (1 min 51 s)". With Qwen thinking, as it does by default, it used a machine and got 111 s in 5 runs of 5. With its thinking turned off it was right in 4 runs of 7, and twice added the waits up in its head to 110.8 s.

In Gno:

```
d := 200
total := 0
for i := 1; i <= 10; i++ {
    if d > 30000 { d = 30000 }
    total += d
    d *= 2
}
fmt.Println(total, "ms")
```

youAdd a `Median` to the stats package, with tests; it's done when `go test ./...` passes. Plan it as steps and do the first one now; we'll carry on in another session.

The agent puts the goal in mem with "`go test ./...` passes" as a step of its own, and a goal cannot be marked done while one of its steps is open: the tests passing is something it has to reach, not claim. When it closes the goal, a separate judge checks it against the conversation, and reopens it if it does not hold. Tomorrow, "Let's carry on with Median." picks up where it stopped, and finishes.

In Gno, the first session:

```
mem.Goal("add Median to stats").Steps("implement Median", "write tests for Median", "go test ./... passes")
```

The next session, told only “Let's carry on with Median”:

```
mem.Show()
```

youRemember these for later sessions: the staging database is db-stg-7, and the on-call engineer is Sam Okafor.

you, a week laterAn update for what you remember: the staging database moved to db-stg-9.

you, any later sessionWhich staging database should I use, and who is on call?

A new session is given the newest facts with your first message, so a fact that changes is set again under its name, not kept twice. In a real run the last session answered without a single call to mem: "Staging database: db-stg-9. On call: Sam Okafor."

```
mem.Fact("fact/staging-db", "the staging database is db-stg-7")
mem.Fact("fact/on-call", "the on-call engineer is Sam Okafor")
```

youBefore we wrap up: remind me next time we talk to rotate the staging API key. It expires this week.

"Morning! Anything I should know before I start?" in the next session brings it back, and so does a session that starts on something else: in a real run the agent did the task it was given and added "PS: don't forget to rotate the staging API key before Friday." It is a reminder for the next session, not an alarm.

In Gno, in another run, where the agent made the reminder a question for you:

```
mem.Goal("rotate staging API key").Ask("staging API key expires this week — rotate it before then")
```

These are real runs with an open-weight model, and [GNOMEM](https://github.com/gnosh-ai/gnosh/blob/main/GNOMEM.md#see-it-work) has them, with how often each passed.

Each of those calls is Gno code the agent writes and Gnosh runs in the Gno VM, against `mem`, a realm kept on your disk for the project. A call changes mem only through mem's own methods; every change is journaled before it is kept, and a call that fails keeps nothing. A new session starts with your rules, what is due, what waits on you, what is open with its next step, and the newest facts.

The calls, as the agent writes them:

```
mem.Goal("release v2").Steps("bump the version", "tag v2.0.0", "CI is green")
```

You can look too: `/mem` shows the outline, `/mem find` searches, `/mem log` lists every change, and `/mem undo` takes one back.