# AI use cases for Pssa (Sparticle62ops/pssa)

Repo: [Sparticle62ops/pssa](https://github.com/Sparticle62ops/pssa) | Use cases: 5 | Page: https://dedupedai.com/use-cases/sparticle62ops-pssa/

PSSA is a small non-transformer language model written from scratch in Rust, with a recurrent state-space layer, episodic memory, and a terminal dashboard.

This file holds every use case of this repo. Each one starts with a "## " heading and ends with its URL.

- Train a PSSA checkpoint and benchmark it against a transformer: https://dedupedai.com/use-cases/sparticle62ops-pssa/train-pssa-and-compare-to-transformer/
- Monitor a long PSSA training run in the terminal dashboard: https://dedupedai.com/use-cases/sparticle62ops-pssa/watch-long-training-run-in-tui/
- Stop PSSA training when the loss blows up: https://dedupedai.com/use-cases/sparticle62ops-pssa/guard-training-against-loss-blowups/
- Chat with a local PSSA checkpoint in the terminal: https://dedupedai.com/use-cases/sparticle62ops-pssa/chat-with-local-checkpoint-in-tui/
- Run the boxes-world recurrent model experiment: https://dedupedai.com/use-cases/sparticle62ops-pssa/run-boxes-world-recurrent-model-experiment/

## How to train a PSSA checkpoint and benchmark it against a transformer with Pssa

Repo: [Sparticle62ops/pssa](https://github.com/Sparticle62ops/pssa) | Difficulty: Intermediate | Time: 1 hour | Basis: From the README

Fit a small PSSA model on your own text, then score it against a matched transformer on held-out tokens.

**Who it is for:** An ML researcher or student who wants to test whether a non-transformer recurrent model learns faster than a transformer on the same corpus.

**The problem:** Comparing a new architecture to a baseline usually means building two training pipelines, which makes the comparison slow and easy to get wrong.

**The outcome:** A trained .pssa checkpoint, a matched transformer baseline, and held-out scores for both models side by side.

### Steps

1. Clone https://github.com/Sparticle62ops/pssa and build the Pssa binary with cargo. (inferred, check the README)
2. Run `pssa train corpus.txt --no-tui` to fit a PSSA checkpoint on your text file. (inferred, check the README)
3. Run `pssa train-transformer corpus.txt` to fit the CPU decoder-only baseline. (inferred, check the README)
4. Run `pssa compare` to replay the PSSA chain with a token and update matched transformer and score both on held-out tokens. (inferred, check the README)
5. Read the JSON scores from `pssa score` and check the two models on the same held-out text.

### Prompt to paste into your agent

```text
Use the Sparticle62ops/pssa repository. Train a PSSA checkpoint on <corpus-path> with `pssa train <corpus-path> --no-tui`, then run `pssa compare`. Report the held-out scores for both the PSSA and transformer models as JSON. Verify that both models were scored on the same held-out tokens before reporting a winner.
```

### Caveat

The README says the architecture learns faster at matched parameters on its own corpus, so your results on a different corpus may differ and should be measured, not assumed.

Disclaimer: Third-party repos we don't own or vouch for. AI-generated use cases can be wrong: review everything and run at your own risk. Full text: https://dedupedai.com/disclaimer/

URL: https://dedupedai.com/use-cases/sparticle62ops-pssa/train-pssa-and-compare-to-transformer/

## How to monitor a long PSSA training run in the terminal dashboard with Pssa

Repo: [Sparticle62ops/pssa](https://github.com/Sparticle62ops/pssa) | Difficulty: Intermediate | Time: 45 minutes | Basis: From the README

Pipe a plain training log into the TUI to watch loss, speed, and checkpoints while training runs.

**Who it is for:** A developer running a long training job on a server, notebook, or Kaggle session who wants a readable live view.

**The problem:** Raw training output scrolls past without context, and long runs are hard to check on at a glance.

**The outcome:** A live dashboard showing loss, a moving average, speed, ETA, update counts, learning rate, memory occupancy, and checkpoint events.

### Steps

1. Build the Pssa binary from the repository. (inferred, check the README)
2. Create an output folder with `mkdir chain` before the first checkpoint is written. (inferred, check the README)
3. Run `pssa train data/downloaded.txt -o chain/ck01.pssa --max-tokens 200000 -e 1 --no-tui | pssa tui --chain chain` to start training and open the dashboard on the piped log. (inferred, check the README)
4. Press Tab in the dashboard to reach the Kaggle launch and log monitoring page if you launched training that way.
5. Check the checkpoint events in the monitor before you stop the run.

### Prompt to paste into your agent

```text
In the Sparticle62ops/pssa repository, run `pssa train <corpus-path> -o chain/ck01.pssa --max-tokens 200000 -e 1 --no-tui | pssa tui --chain chain`. Report the loss, speed, and checkpoint events shown in the monitor. Verify that the file chain/ck01.pssa exists after the run.
```

### Caveat

The README says the TUI shows piped output as a plain log passthrough when not on a terminal, so the interactive dashboard needs a real terminal.

Disclaimer: Third-party repos we don't own or vouch for. AI-generated use cases can be wrong: review everything and run at your own risk. Full text: https://dedupedai.com/disclaimer/

URL: https://dedupedai.com/use-cases/sparticle62ops-pssa/watch-long-training-run-in-tui/

## How to stop PSSA training when the loss blows up with Pssa

Repo: [Sparticle62ops/pssa](https://github.com/Sparticle62ops/pssa) | Difficulty: Intermediate | Time: 45 minutes | Basis: From the README

Use the loss guard flags to abort a run before a bad loss overwrites a good checkpoint.

**Who it is for:** A researcher running an unattended training job who wants to avoid losing a good checkpoint to a loss spike.

**The problem:** A loss blow-up can silently replace a good checkpoint with a broken one during a long unattended run.

**The outcome:** A training run that aborts after three consecutive suspect loss groups without writing or replacing a checkpoint, plus a halt reason in the monitor.

### Steps

1. Build the Pssa binary from the repository. (inferred, check the README)
2. Run `pssa train corpus.txt --loss-guard-high-factor 4 --loss-guard-jump-factor 8 --loss-guard-patience 3` to start training with explicit guard settings.
3. If you resume a run, repeat the same custom guard values on the resume command, since they are runtime only.
4. Open `pssa tui` to see the configured guard and any halt reason in the monitor.
5. Keep the last good checkpoint and compare any new checkpoint before using it.

### Prompt to paste into your agent

```text
In the Sparticle62ops/pssa repository, run `pssa train <corpus-path> --loss-guard-high-factor 4 --loss-guard-jump-factor 8 --loss-guard-patience 3`. Report whether the run finished or halted, and the halt reason if it halted. Verify that no checkpoint was replaced after a halt.
```

### Caveat

The README says this is not a held-out validation monitor and a resumed run starts a fresh loss history, so the guard does not measure generalization.

Disclaimer: Third-party repos we don't own or vouch for. AI-generated use cases can be wrong: review everything and run at your own risk. Full text: https://dedupedai.com/disclaimer/

URL: https://dedupedai.com/use-cases/sparticle62ops-pssa/guard-training-against-loss-blowups/

## How to chat with a local PSSA checkpoint in the terminal with Pssa

Repo: [Sparticle62ops/pssa](https://github.com/Sparticle62ops/pssa) | Difficulty: Intermediate | Time: 45 minutes | Basis: From the README

Load a trained checkpoint in the TUI inference page and talk to it, with saved conversations.

**Who it is for:** A developer who has a trained PSSA or TRFM checkpoint and wants to try its replies without writing code.

**The problem:** Testing a trained checkpoint usually means writing a script, and past conversations are easy to lose.

**The outcome:** A streamed chat with the model, live tokens per second, and saved conversation files in the chats folder.

### Steps

1. Build the Pssa binary from the repository. (inferred, check the README)
2. Run `pssa tui` in a terminal.
3. Press Tab to reach inference, then type `/model` to list checkpoints in your chain folder or data folder.
4. Type `/model PATH` with the path to your checkpoint and press Enter after typing a message.
5. Use `/new` to start a new conversation and `/chats` to list saved ones.

### Prompt to paste into your agent

```text
In the Sparticle62ops/pssa repository, start `pssa tui`, select a checkpoint with `/model <checkpoint-path>`, and send one message. Report the reply and the tokens per second shown. Verify that a JSON file was written in the chats folder.
```

### Caveat

The README says checkpoint loading cannot be interrupted, so a large checkpoint may take a while before Esc or /stop has any effect.

Disclaimer: Third-party repos we don't own or vouch for. AI-generated use cases can be wrong: review everything and run at your own risk. Full text: https://dedupedai.com/disclaimer/

URL: https://dedupedai.com/use-cases/sparticle62ops-pssa/chat-with-local-checkpoint-in-tui/

## How to run the boxes-world recurrent model experiment with Pssa

Repo: [Sparticle62ops/pssa](https://github.com/Sparticle62ops/pssa) | Difficulty: Advanced | Time: 1 hour | Basis: From the README

Train an RSSM-style PSSA against a plain autoregressive control on a tiny box-pushing grid.

**Who it is for:** A research engineer studying recurrent world models who wants a small, bounded experiment to compare against a plain control.

**The problem:** Testing whether stochastic latents help a recurrent model needs a controlled setup with a fair baseline, which is slow to build from scratch.

**The outcome:** Held-out next-frame NLL, open-loop NLL, accuracy, reward and continuation Brier scores, and timing for both models in one report.

### Steps

1. Build the Pssa binary from the repository. (inferred, check the README)
2. Run `pssa world-model` for the default bounded experiment.
3. Run `pssa world-model --seed 73 --train-episodes 32 --heldout-episodes 12 --epochs 3` to change the seed and episode counts.
4. Run `pssa world-model --help` to see grid size, widths, learning rate, and other settings.
5. Compare the RSSM-style model with the plain control in the report, and note that the comparison is not parameter or time matched.

### Prompt to paste into your agent

```text
In the Sparticle62ops/pssa repository, run `pssa world-model --seed <seed> --train-episodes 32 --heldout-episodes 12 --epochs 3`. Report the held-out next-frame NLL for the RSSM-style model and the plain control. Verify that the report states the comparison is not parameter or time matched before drawing any conclusion.
```

### Caveat

The README says neither model solved the task at the default budget and the stochastic model was about 4.5 times slower, so this is a research probe, not an agent or planning benchmark.

Disclaimer: Third-party repos we don't own or vouch for. AI-generated use cases can be wrong: review everything and run at your own risk. Full text: https://dedupedai.com/disclaimer/

URL: https://dedupedai.com/use-cases/sparticle62ops-pssa/run-boxes-world-recurrent-model-experiment/