Skip to content
Rheticus

Bring any model. Keep your record.

The app owns the structured learning record. Models and agents are interchangeable workers on it, so nothing about your learning lives in a vendor's memory feature.

Your learning recordOne SQLite file, on your computerThe model you bring
Anthropic
OpenAI
Google Gemini
OpenRouter
OllamaThe agents you use
Claude Code
Codex
Any MCP clientPlain Markdown, any time
Answering now: AnthropicSwitch the model and the record does not change. Agents reach it through the MCP server.

Fifteen ways in, today.

Every provider the app connects to now. More are on the way, and any OpenAI-compatible endpoint already works.

  • AnthropicHosted
  • OpenAIHosted
  • Google GeminiHosted
  • OpenRouterGateway
  • OmniRouteGateway
  • GroqHosted
  • MistralHosted
  • DeepSeekHosted
  • xAIHosted
  • Together AIHosted
  • FireworksHosted
  • CerebrasHosted
  • OllamaOn your machine
  • LM StudioOn your machine
  • Any OpenAI-compatible endpointAny address

Three ways in, often confused.

They run in different directions, so each is stated on its own.

  • Bring your own model

    Rheticus calls a model

    Paste a provider API key, use a router such as OpenRouter, or point the app at a model on your own machine. Add several keys to one provider and they are used in turn.

  • Connect an agent

    An agent calls Rheticus

    The app runs a small MCP server on your machine with a handful of scoped learning tools. Claude Code, Codex and other MCP clients can read your plan, fetch your next task and record an attempt.

  • Just use the files

    Anything reads Markdown

    Export a track, or everything, to plain Markdown with front matter. Any editor or agent can read it without Rheticus installed.

What this does not mean: Rheticus does not embed another product's interface, and it cannot use a consumer chat subscription as an API.

What each job asks of a model.

Some work needs a capable model. The planner, the schedule and every question code can mark need none at all.

JobStructured outputOn a small local model
Curriculum Architect: mapping a fieldNeededOften struggles
Tutor: teaching a lesson in partsNeeded for the planUsually manages
Assessor: writing questionsNeededSometimes
Assessor: markingNeeded for written answersCode marks what code can
Planner, schedule and reviewsNo model at allAlways works

The MCP server: small on purpose.

Off until you turn it on. Agents get a few tools and only the access you grant, one agent and one tool at a time.

  • get_capabilities

    What this agent may do, and the rules agents follow

    Read
  • list_tracks

    Your tracks, with counts per mastery state

    Read
  • get_track_plan

    Modules and lessons, with states and what each needs first

    Read
  • get_competency

    One lesson: state, misconceptions, recent attempts, next review

    Read
  • get_next_task

    The planner's next steps, each with its reason

    Read
  • search_library

    Notes and the sources you let agents read

    Read
  • record_attempt

    Submit an answer. Code marks what code can

    Write
  • propose_note

    A note for your vault, waiting for your approval

    Propose
  • propose_item

    A practice question, waiting for your approval

    Propose
  • propose_evidence

    A mark. Always provisional, always under the agent's name

    Propose
Agent configuration
{
  "mcpServers": {
    "rheticus": {
      "command": "rheticus",
      "args": ["--mcp"],
      "env": { "RHETICUS_MCP_TOKEN": "the token the app shows you" }
    }
  }
}

Four permission modes

Deny
The tool is unavailable to this agent.
Read
Read tools return data. Private notes are never included.
Propose
Writes arrive as proposals you approve in the app. This is the default.
Write
Applies at once. Offered only for recording attempts and notes, never for evidence.

Not exposed at all: deleting anything, editing the curriculum, changing settings, reading keys, or raising a mastery state directly. Every call is logged on your machine.

The parts worth saying out loud.

Model independence comes with trade-offs. Here they are.

  • An API key is not a chat subscription

    Providers bill API usage separately from their consumer chat plans. The app says so during setup, counts what each request cost, and stops at caps you set by day, week or month.

  • You see where your material goes

    The model in use is always on screen, and you choose which model does which job: conversations, background work and search.

  • Keys stay out of reach

    Keys live in your operating system's credential store. They are never written to the database, the logs, an export or a note.

  • Some tracks never leave

    Mark a track as local-only and it refuses hosted providers and is invisible to every external agent.

  • Small models have limits

    A small local model may not manage structured work such as mapping a field. The app says so plainly, and leans on questions code can mark where it can.

  • Agent evidence is always provisional

    An outside agent is a model the app did not configure. Its markings move a state visibly as provisional and carry the agent's name.

Your model. Your agents. Your record.

Free during the early beta, with everything unlocked. Join the beta and the Windows build comes to you first.

Join the betaDownload