temper

Temper is an event-sourced coordination substrate whose organizing purpose is to be economical with attention. A cognitive map is a telos-seeded region of that substrate where humans and agents grow a shared, situated understanding together — and everything else, personal knowledge management included, is a projection over it. Everything resolves to markdown; the system gets out of the way.

Substrate, and one projection over it

Temper is a coordination substrate first. The conceptual frame — what a cognitive map is, what the architecture fixes versus what a deployment shapes, and the commitments underneath — lives on the site: start with cognitive maps (the concrete on-ramp), operating (running it, for the evaluator), and theory (the why).

The rest of this README is the personal-knowledge projection — the view a solo builder or small team uses to keep an agent's context coherent across sessions. A true and useful view, not the whole story.

The problem it solves

AI coding agents are powerful but forgetful. Every session starts blank — no memory of yesterday's decisions, no awareness of in-flight work, no sense of what matters next. The industry calls this context rot: the progressive degradation of an agent's understanding as work spans sessions.

Developers compensate by re-explaining context, pasting old chat logs, and manually steering agents through decisions the agent should already know about. This tax grows with every session. The fix is throughline — knowing what's been done, what's up next, what's decided and what's still open.

Throughline

In the personal-knowledge projection, goals hold the vision, tasks carry the work, and sessions record what happened. Each layer provides context for the layer below, and each session's conclusions feed back up — refining the goals, sharpening the path forward. (Underneath, each of those is an event on the substrate; the projection is one honest view of the ledger.)

This isn't a ticketing system competing with Linear. It's a structured knowledge base where every goal, task, session, decision, and research thread has a home — and where the connections between them are always visible.

Session continuity

Every new session starts with temper warmup, which surfaces active goals, in-progress tasks, recent sessions, and pending invitations. The agent resumes where you left off instead of starting from scratch.

At the end of each session, a session note (temper resource create --type session) captures what happened — decisions made, tasks updated, next steps identified — written straight through the cloud to the substrate. The next session reads it. Context compounds instead of decaying.

Goals and tasks

Temper gives you two building blocks:

Goals are the outcomes you're working toward. A goal holds the vision and purpose of a feature, a product, a body of work. Tasks and sessions roll up to goals.

Tasks are units of work toward a goal. Every task has a mode — build or plan — and an expected effort — small, medium, or large. Your workflow preferences (set during temper init) shape how these translate into process — temper carries the throughline regardless of what tools and ceremonies you prefer.

For humans and agents

Temper gives agents the same throughline that humans carry in their heads: what we're building, why, what we've decided, and what's deferred. Agents reach your knowledge base three ways:

• CLI — temper warmup, temper search, temper resource create. Claude Code hooks call temper warmup automatically at session start.
• MCP Server — knowledge-base operations exposed as structured tools. Agents query, read, and write through the Model Context Protocol.
• Skill File — temper skill install generates a Claude Code skill that teaches the agent your knowledge base's structure and workflow conventions.

If it can read markdown, it can use temper.

Install

The fastest way to try temper is the one-liner installer — no Rust toolchain needed.

macOS (Apple Silicon) and Linux (x86_64):

curl -fsSL https://raw.githubusercontent.com/tasker-systems/temper/main/scripts/install/install.sh | sh

Homebrew (macOS Apple Silicon, Linux x64):

brew install tasker-systems/tap/[email protected]

Installing by the full versioned name trusts that formula — no brew trust step. See the install playbook for the temper alias and Brewfiles.

Windows (x86_64, PowerShell):

irm https://raw.githubusercontent.com/tasker-systems/temper/main/scripts/install/install.ps1 | iex

Supported platforms: macOS (Apple Silicon), Linux (x86_64), and Windows (x86_64) — please file issues at https://github.com/tasker-systems/temper/issues if you hit problems.

For version pinning, uninstall instructions, and building from source (including Linux arm64 and Intel Mac), see the install playbook.

Quick Start

# Initialize — temper writes your config and ensures your default context server-side
temper init

# Log in (browser OAuth, PKCE). `temper auth status` shows where you stand.
temper auth login

# Create a context for your project on the server
temper context create myapp

# Add a document — temper extracts markdown and ingests it via the cloud pipeline
temper resource create --from ~/projects/myapp/docs/design.md --context @me/myapp

# Search across your knowledge base
temper search "authentication decisions"

# Generate and install the Claude Code skill
temper skill install

# Write a session note (body via --body @file or piped stdin)
temper resource create --type session --context @me/myapp --title "Implemented auth flow, chose JWT rotation"

This is the beginning of the README. Read the rest at the original. Read the full README ↗