Model modifications

Train weights, edit knowledge, or work with activations. Explore how each method changes a model.

SFT & LoRA

Train on examples of the answers you want. SFT supplies the learning objective; LoRA updates a small adapter while the base weights stay frozen.

Reviewed examplesInputs and approved answers

Supervised trainingLearn from target-token loss

Trained adapterSave with its exact base model

Support conversation

Frozen base model

Train LoRA weights

Your answer format

Added adapter weights

ExampleTeach a support model to return your response format from reviewed conversations.

Reinforcement learning

Use rewards to train the model from its own responses. GRPO compares groups of responses and updates the policy toward the higher-scoring ones.

Generate responsesRun the current model

Grade a groupApply your reward function

Update the policyTrain the next adapter

Math problem

Policy model

Reward → policy update

Candidate answers

Trained policy / adapter weights

ExampleReward correct math answers with a deterministic grader, then evaluate on separate problems.

Neuron training

Select neurons that matter for a target domain and remain quiet across background domains. Train their output projection columns, then save the learned delta against the unchanged base checkpoint.

Target + background domainsReviewed target and background examples

Select neuronsSelection uses activity and gradients

Train a column deltaSave exact learned columns for inference

Reviewed domain examples

Selected projection columns

Train column weights

Learned neuron delta

Saved weight delta; base checkpoint stays immutable

ExampleAdapt responses for a target domain while measuring selected neuron activity across separate background domains.

Neuron steering

Change selected neuron activations during a forward pass. Store the layers, coordinates and doses as a profile, and compare the response with steering off.

Choose neuronsLayer and neuron coordinates

Apply a doseIntervene during inference

Compare responsesOriginal profile / Off

Same prompt

Hidden activationsSelected neurons ± dose

Steered response

Runtime activations; base weights stay fixed

ExampleApply a positive dose to one neuron and a negative dose to another, then compare the same prompt.

Inspect activations

Look at activity across prompt tokens, layers and neurons. Inspection captures what happens inside a model without applying an intervention or changing its weights.

Run a promptExact model and tokenizer

Capture activationsSelected layers and neurons

Inspect by tokenRetained observation evidence

Prompt tokens

Model layersRead selected activations

Activation capture

Observation only; weights and activations are unchanged

ExampleRun a prompt and inspect which selected neurons activate at each token.

Engram memory

Train an added memory module that looks up recurring token sequences. Learned tables and gates feed that memory into the model's hidden states while the base stays frozen.

Token sequencesBuild n-gram lookup keys

Memory lookupLearn tables and projections

Gated hidden updateInsert the trained module

Token n-grams

Frozen base model

Lookup tables + learned gateAt selected layers

Memory-informed output

Added trainable memory-module weights

ExampleTrain lookup memory for repeated product names and domain terminology on a compatible Qwen model.

Decision models

Score a defined set of choices from state and a question. Train an adapter on approved decisions, then return every allowed choice's probability from its candidate logits.

State and choicesDescribe the decision

Candidate logitsScore every allowed answer

Choice distributionReturn scores, not generated JSON

Ticket + routes

Decision model

Train from approved targets

Scores for every route

Trained decision-adapter weights; typed scoring at inference

ExampleRoute a support ticket to billing, technical support or account help, with scores for each choice.

AlphaEdit

Edit a factual association in compatible model weights. AlphaEdit constrains the update with a null-space projection to limit interference with other knowledge.

A factual editSubject, relation and target

Constrained weight updateProject the update before applying

Edited modelCheck the edit and locality

New factual target

Model weight matrixApply constrained ΔW

Updated association

Existing model weights

ExampleUpdate a product's manufacturer, then check paraphrases and unrelated facts.

Ponder Training

Train from examples with supervised fine-tuning (SFT), or use reinforcement learning (RL) to learn from rewards. Ponder Training handles the training run, checkpoints and model serving from the same experiment setup.

SFT & LoRA: Use reviewed input-and-answer pairs to teach a response format or task. Train a LoRA adapter, then evaluate against your starting model.
RL with GRPO: Generate groups of responses, score them with your graders, and update the policy from those rewards. Keep evaluation tasks separate from training data.
Continual learning: Collect new examples and continue from an existing trained version. Review each update before choosing which version to serve.

Explore Ponder Training

Training loopLoRA adapter

RolloutsGenerate responses
GradeScore with your rewards
Update LoRATrain adapter weights
CheckpointVersion your adapter
EvaluateCompare with baseline
ServeCall your model API

New outcomes. Next adapter.

OpenPond Desktop & Harness

Work with agents beside your local projects, then turn a dataset into an evaluation plan without leaving the app.

Explore Desktop

Build your own models.