Skip to content
Back to search

tinker-ai-skill

SkillWorks with Claude CodeGitHub

Turn your own coding-agent session transcripts (Claude Code JSONL) into a supervised fine-tuning dataset and train a LoRA on Tinker with the tinker-cookbook. Use when the user wants to fine-tune a model on their agent sessions, build an SFT dataset from transcripts, anonymize or de-identify transcripts, slice long sessions to a context length with compaction context, or train and evaluate on Tinker. Covers collection, cleaning (secrets, PII, paths), chunking, train/val splits, training, sampling, and the pitfalls that cost us runs.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/drost-ai--tinker-ai-skill/badge.svg)](/listings/drost-ai--tinker-ai-skill)

HTML

<a href="/listings/drost-ai--tinker-ai-skill"><img src="/api/listings/drost-ai--tinker-ai-skill/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

git clone https://github.com/drost-ai/tinker-ai-skill.git ~/.claude/skills/tinker-ai-skill
cd ~/.claude/skills/tinker-ai-skill
uv venv && source .venv/bin/activate && uv pip install -r requirements.txt

python scripts/make_sample_transcript.py --out ./demo-claude-projects --turns 14 --long-results
python scripts/collect_sessions.py   --claude-dir ./demo-claude-projects --data-dir ./demo-data --min-bytes 1000
python scripts/normalize_sessions.py --data-dir ./demo-data
python scripts/anonymize_sessions.py --data-dir ./demo-data --name "Taylor Quintrell"
python scripts/build_dataset.py      --data-dir ./demo-data --model Qwen/Qwen3.6-35B-A3B --max-len 8192 \
                                     --system-prompt-file assets/system-prompt.md
python scripts/train_tinker.py       --data-dir ./demo-data --name qwen3.6-35b-a3b-8k   # offline smoke test

The last command prints a decoded training row, the token count and the resolved configuration. Add `--train` to launch a real run; afterwards `export_checkpoint.py` and `make_gguf.sh` take it to a GGUF you can run.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

SKILL.md · Manifest · 193 lines
  1. ---
  2. name: tinker-ai-skill
  3. description: Turn your own coding-agent session transcripts (Claude Code JSONL) into a supervised fine-tuning dataset and train a LoRA on Tinker with the tinker-cookbook. Use when the user wants to fine-tune a model on their agent sessions, build an SFT dataset from transcripts, anonymize or de-identify transcripts, slice long sessions to a context length with compaction context, or train and evaluate on Tinker. Covers collection, cleaning (secrets, PII, paths), chunking, train/val splits, training, sampling, and the pitfalls that cost us runs.
  4. license: MIT
  5. compatibility: Python 3.11+, uv or pip, tinker-cookbook>=0.6.0 (installs tinker, torch, tml-renderers), a Tinker API key, optionally a Weights & Biases API key. Scripts run from the skill directory; dataset steps are offline, training and sampling call the Tinker service and cost money.
  6. metadata:
  7. author: Migel Tissera
  8. version: "1.0.0"
  9. source: https://github.com/drost-ai/tinker-ai-skill
  10. ---
  11. # Fine-tune a coding model on your own agent transcripts (Tinker)
  12. You are helping someone turn the sessions they already ran with a coding agent into
  13. training data, and fine-tune an open model on it with [Tinker](https://thinkingmachines.ai/tinker).
  14. This skill distils a pipeline that shipped several public models. Follow the steps
  15. in order; each script is small, offline unless stated, and prints what it did.
  16. All commands below run from this skill's directory (`tinker-ai-skill`). Read `references/` when a step
  17. needs judgement; the scripts' docstrings (`python scripts/<name>.py --help`) explain
  18. every flag.
  19. ## Before you start
  20. 1. **Keep the transcripts.** Claude Code deletes transcripts after 30 days by default.
  21. Tell the user to add `"cleanupPeriodDays": 3650` to `~/.claude/settings.json` now.
  22. 2. **Keys.** Copy `.env.example` to `.env` and fill in `TINKER_API_KEY`
  23. (console at tinker.thinkingmachines.ai) and `WANDB_API_KEY` (wandb.ai/authorize).
  24. Never print, commit, or paste these values anywhere; the scripts read `.env`.
  25. 3. **Environment.** `uv venv && uv pip install -r requirements.txt` (or `pip install -r requirements.txt`).
  26. Python 3.11+. Use that interpreter for every script.
  27. 4. **Budget.** Training costs tokens x price. Always run a script's default (offline)
  28. mode first; only `--train`, `sample_checkpoint.py` and `export_checkpoint.py` touch
  29. the service. Confirm the estimated cost with the user before launching.
  30. 5. **For local serving (steps 8-9).** A built [llama.cpp](https://github.com/ggml-org/llama.cpp)
  31. checkout recent enough for the model's architecture, disk for the base model plus
  32. the merged copy (about 2 bytes per parameter each), and RAM for the largest shard.
  33. ## The workflow
  34. ### Step 1. Collect transcripts into a dataset location
  35. ```
  36. python scripts/collect_sessions.py --data-dir ./data # ~/.claude/projects by default
  37. python scripts/collect_sessions.py --data-dir ./data --project my-repo --since 2026-01-01
  38. ```
  39. Copies main-session files verbatim (no subagent sidechains), skips tiny sessions,
  40. records sha256s in `data/originals/manifest.json`. Use `--exclude-slug` for projects
  41. that must never leave the machine (client work, security research).
  42. ### Step 2. Clean: normalize, then remove secrets and identity
  43. ```
  44. python scripts/normalize_sessions.py --data-dir ./data
  45. python scripts/anonymize_sessions.py --data-dir ./data --identity-file identity.json
  46. ```
  47. `normalize_sessions.py` turns the raw records into OpenAI-style messages: user text
  48. the person typed, assistant text and plaintext thinking, tool calls with their JSON
  49. arguments, tool results clipped to head+tail. It drops harness-injected text,
  50. sidechains, API-error placeholders, thinking signatures and image bytes, and
  51. verifies every tool call is answered. See `references/claude-code-transcripts.md`.
  52. `anonymize_sessions.py` first replaces credentials by value across the whole corpus
  53. (one marker per value), then de-identifies each session with its OWN random
  54. identity: home username, top-level folders under the home directory, project slugs,
  55. and every name/email/handle/org/domain listed in the identity file. Write that file
  56. with the user (their username, full name, emails, GitHub handle, company). The run
  57. fails if any listed string or credential candidate survives. Read the printed list
  58. of detected usernames; pass `--keep-username` for service accounts that are not a
  59. person. Why per-session randomization and not one fixed fake world:
  60. `references/anonymization.md`.
  61. Inspect a few anonymized rows with the user before continuing. Only the user can
  62. judge whether something is still sensitive.
  63. ### Step 3-5. Slice to the context length, add compaction context, split train/val
  64. ```
  65. python scripts/build_dataset.py --data-dir ./data --model Qwen/Qwen3.6-35B-A3B --max-len 65536 \
  66. --system-prompt-file assets/system-prompt.md
  67. ```
  68. Pick `--model` from Tinker's model list and `--max-len` from that model's context
  69. column (64K base variants; `:peft:262144` variants take 256K). The builder measures
  70. every row with the real renderer and tokenizer of that model, so **rebuild when you
  71. change models**: a tokenizer change moved our rows by 14% and overflowed the budget.
  72. - Windows never split a tool call from its result and never open on a tool message.
  73. - Slice 0 carries the system prompt plus the working directory. Every later slice
  74. carries the same prompt followed by a deterministic `<working_context>` block
  75. (original request, recent requests, files touched, commands, task state, a trace
  76. of the last few messages) and, when the window opens mid-turn, a short
  77. "continuation" user message. This is the compaction the model will see in a real
  78. long session. Details: `references/chunking-and-compaction.md`.
  79. - Tool definitions are declared on every row. Pass `--tools-file` with the real
  80. definitions of the harness the model will serve in; without it, minimal schemas
  81. are inferred from usage. Rows without tool definitions regressed tool use for us.
  82. - Hybrid-thinking renderers are rebuilt to keep thinking in history (otherwise
  83. earlier turns train on empty think blocks). For Inkling models pass `--effort`
  84. (default 0.9) and use the same value at serving time.
  85. - The split is by whole session, seeded, so rebuilds hold out the same sessions.
  86. Report: `data/datasets/<name>.report.json` (rows, tokens, loss tokens, sha256s,
  87. rendering provenance). The trainer refuses a dataset whose provenance differs.
  88. ### Step 6. Fine-tune on Tinker
  89. ```
  90. python scripts/train_tinker.py --data-dir ./data --name qwen3.6-35b-a3b-64k # offline smoke test
  91. python scripts/train_tinker.py --data-dir ./data --name qwen3.6-35b-a3b-64k --train # launch
  92. ```
  93. The smoke test renders every row, prints the decoded head of a row (read it: system
  94. prompt, tool declaration, user turn), steps per epoch and total tokens. Multiply
  95. tokens by the model's train price from Tinker's pricing page and tell the user the
  96. estimate before `--train`.
  97. Defaults: LoRA rank 32, batch 8 rows, 2 epochs, linear decay, eval and checkpoint
  98. every 20 steps, W&B project `agent-transcript-sft`. Learning rate comes from
  99. Tinker's calibrated `get_lr` for Qwen/Llama; for Inkling, Nemotron, DeepSeek, Kimi
  100. and GLM you must pass `--learning-rate` (ranges and evidence in
  101. `references/tinker-training.md`). When in doubt run two short runs, 1e-4 and 3e-4,
  102. and compare behaviour, not loss.
  103. While it runs: confirm the first metrics reach W&B, watch `test/nll` at steps 20 and
  104. 40 (a dip then a rise means the LR is too hot for this batch; stop and lower it),
  105. and never wrap Tinker calls in your own timeouts or retries.
  106. ### Step 7. Check behaviour and pick a checkpoint
  107. ```
  108. python scripts/sample_checkpoint.py --data-dir ./data --name qwen3.6-35b-a3b-64k \
  109. --checkpoint tinker://<run-id>/sampler_weights/000100 --prompt "Find and fix the failing test."
  110. ```
  111. Compare base vs checkpoints on prompts from the user's real work. Judge by behaviour
  112. (valid tool calls, non-empty thinking, follows the system prompt), not by NLL: a
  113. falling loss hid a behaviour regression for us twice. Pick the checkpoint by an eval.
  114. ### Step 8. Download the LoRA and merge it into the base model
  115. ```
  116. python scripts/export_checkpoint.py --run-dir ./runs/<run> --checkpoint 000100 \
  117. --base-model Qwen/Qwen3.6-35B-A3B --out ./export/my-coder --trust-remote-code
  118. ```
  119. Reads `checkpoints.jsonl`, downloads the **training** checkpoint (sampler
  120. checkpoints cannot be downloaded; periodic ones expire after 7 days, so export
  121. before then), merges it with the cookbook's `build_hf_model` into a standalone bf16
  122. HuggingFace directory, copies `generation_config.json`, and prints the chat-template
  123. kwarg that restores the training conditioning (earlier-turn thinking kept).
  124. `--peft` additionally writes a PEFT adapter for vLLM or SGLang. `--dry-run` shows
  125. the plan without contacting Tinker. Details and memory needs:
  126. `references/export-and-serve.md`.
  127. ### Step 9. Convert to GGUF and run with llama.cpp
  128. ```
  129. LLAMA_CPP=~/src/llama.cpp scripts/make_gguf.sh ./export/my-coder/hf-merged ./export/my-coder/gguf my-coder Q4_K_M Q8_0
  130. scripts/serve_gguf.sh ./export/my-coder/gguf/my-coder-Q4_K_M.gguf
  131. ```
  132. `make_gguf.sh` converts to BF16 GGUF with the checkout's `convert_hf_to_gguf.py`,
  133. quantizes with the `llama-quantize` built from the same commit, exports the vision
  134. projector when the model has one, and optionally the MTP draft head (`MTP=1`).
  135. `serve_gguf.sh` starts `llama-server` with the settings that match training:
  136. `--jinja`, `--reasoning-preserve`, the template kwarg for preserved thinking, a
  137. context of at least the training window, and the base model's sampling defaults
  138. (temperature 1.0, top-p 0.95, top-k 20, min-p 0). Smoke-test one prompt with a
  139. tool before trusting it, then benchmark against a same-recipe base GGUF.
  140. ## Rules that saved us the most time
  141. - Never hardcode a renderer name; resolve it from the model with
  142. `model_info.get_recommended_renderer_name`. Never reuse a dataset rendered for one
  143. model with another model.
  144. - Never anonymize with one constant fake world. Randomize per session.
  145. - Never train rows without the system prompt and tool definitions the model will be
  146. served with.
  147. - Never trust a loss curve alone. Sample.
  148. - Never serve with a chat template that strips earlier-turn thinking when training
  149. kept it, and never with llama.cpp's default min-p: match the template kwarg and the
  150. base model's sampling defaults.
  151. - Never put data, `.env`, run or export directories in a public repo: the pack's
  152. `.gitignore` covers `data/`, `runs/`, `export/`, `wandb/`, `.env`.
  153. ## Adapting to other agents
  154. The normalizer reads Claude Code's JSONL. For Codex, OpenCode or your own harness,
  155. write a normalizer that emits the same per-session file (`references/claude-code-transcripts.md`
  156. documents the message schema); every later step is format-independent.
README.md · README · 202 lines
  1. # tinker-ai-skill
  2. **Turn your own coding-agent sessions into a fine-tuned model you can run locally. This is the recipe behind Tess-4 and Tess-4.5.**
  3. [![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE)
  4. [![Agent Skill](https://img.shields.io/badge/Agent%20Skill-agentskills.io-black)](https://agentskills.io)
  5. [![Works with](https://img.shields.io/badge/works%20with-Claude%20Code%20%C2%B7%20Codex%20%C2%B7%20OpenCode-brightgreen)](#install-the-skill)
  6. [![Trains on](https://img.shields.io/badge/trains%20on-Tinker-7b3fe4)](https://thinkingmachines.ai/tinker)
  7. Every session you run with a coding agent is a worked example of how you want a
  8. model to behave: your repositories, your conventions, your tools, your way of
  9. debugging. This skill hands your agent the complete, production-tested pipeline to
  10. turn those sessions into a supervised fine-tuning dataset, train a LoRA on
  11. [Tinker](https://thinkingmachines.ai/tinker), merge it, and ship a GGUF that runs in
  12. llama.cpp on your own machine. One afternoon, a few dollars to a few hundred, and a
  13. model that works the way you do.
  14. Install it once and say: *"fine-tune Qwen3.6-35B-A3B on my Claude Code sessions from
  15. the last three months."* The agent takes it from there and stops before anything
  16. that costs money.
  17. ## Proven on real releases
  18. We built the Tess family of agentic coding models from our own Claude Code sessions
  19. with exactly this method, and shipped them as open weights on Hugging Face:
  20. [Tess-4-27B](https://huggingface.co/migtissera/Tess-4-27B)
  21. ([GGUF](https://huggingface.co/migtissera/Tess-4-27B-GGUF),
  22. [EAGLE-3 draft](https://huggingface.co/migtissera/Tess-4-27B-EAGLE3)) and
  23. [Tess-4.5-27B](https://huggingface.co/migtissera/Tess-4.5-27B)
  24. ([GGUF](https://huggingface.co/migtissera/Tess-4.5-27B-GGUF)). Read about them at
  25. [continuityresearch.ai/tess-4-5](https://continuityresearch.ai/tess-4-5).
  26. What is in this repository is the distilled, cleaned-up version of the pipeline that
  27. produced them, from raw transcripts to a quantized GGUF, including the mistakes we
  28. made so you do not have to.
  29. ## What you get
  30. - **One `SKILL.md`** your agent follows: a nine-step workflow with the decision
  31. points spelled out and the rules that cost us runs.
  32. - **Eleven small scripts**, plain Python and shell on top of tinker-cookbook and
  33. llama.cpp, each with an offline default and a `--help` that explains every flag.
  34. - **Six reference notes**: the transcript format, the anonymization policy, the
  35. chunking and compaction design, Tinker training settings with the learning-rate
  36. evidence, export and serving, and the lessons learned.
  37. - **A synthetic transcript generator** so you can dry-run the whole pipeline in
  38. five minutes without touching real data or spending a cent.
  39. ## The method, from transcripts to a local model
  40. | Step | What happens | Script |
  41. |---|---|---|
  42. | 1. Collect | Copy Claude Code transcripts verbatim, with checksums; skip subagents and tiny sessions; exclude whole projects that must stay private | `collect_sessions.py` |
  43. | 2. Clean | Normalize to OpenAI-style messages; drop harness noise; replace every credential by value; give each session its own random identity for usernames, folders, names, emails, orgs; fail if anything leaks | `normalize_sessions.py`, `anonymize_sessions.py` |
  44. | 3. Slice | Cut sessions to the model's context length, measured with the model's real renderer, never splitting a tool call from its result | `build_dataset.py` |
  45. | 4. Compact | Give every slice after the first a deterministic working-context block and a continuation bridge, the way a real harness compacts | `build_dataset.py` |
  46. | 5. Split | Hold out whole sessions with a seeded hash so rebuilds and other models compare | `build_dataset.py` |
  47. | 6. Train | LoRA on Tinker with the cookbook trainer, tool definitions on every row, W&B connected, offline smoke test first, cost shown before launch | `train_tinker.py` |
  48. | 7. Check | Sample base vs checkpoints with identical rendering; judge behaviour, not loss | `sample_checkpoint.py` |
  49. | 8. Merge | Download the LoRA from Tinker and merge it into the base model as a standalone bf16 HuggingFace model (or a PEFT adapter for vLLM/SGLang) | `export_checkpoint.py` |
  50. | 9. Ship | Convert to GGUF, quantize, export the vision projector and draft head, and serve with llama.cpp using the training-matched template and sampling settings | `make_gguf.sh`, `serve_gguf.sh` |
  51. ## Why this and not a generic SFT tutorial
  52. Agent transcripts are not chat data. The details below are the difference between a
  53. model that works and one that looks fine on the loss curve and falls apart in use.
  54. - **Per-session anonymization.** A single constant fake world in every row was
  55. memorized and later asserted over the real environment. Randomize per session.
  56. - **Compaction context on continuation slices.** Long sessions outlive the context
  57. window; the model must learn to continue from a summary, not from nothing.
  58. - **Tool definitions and the system prompt on every row.** Rows without them
  59. regressed tool use even though NLL improved.
  60. - **Thinking kept in history.** Hybrid renderers silently strip earlier reasoning and
  61. train empty think blocks; the scripts rebuild the renderer to keep it.
  62. - **Measure with the real tokenizer.** A tokenizer change moved rows by 14% and
  63. overflowed the budget. Rebuild per model.
  64. - **Judge by behaviour.** Two "collapses" had monotonically falling loss. Sample.
  65. - **Serve the way you trained.** A chat template that strips earlier thinking, or
  66. llama.cpp's default min-p, turned a good checkpoint into garble. The serve script
  67. carries the right flags.
  68. ## Quick start: five minutes on synthetic data
  69. ```
  70. git clone https://github.com/drost-ai/tinker-ai-skill.git ~/.claude/skills/tinker-ai-skill
  71. cd ~/.claude/skills/tinker-ai-skill
  72. uv venv && source .venv/bin/activate && uv pip install -r requirements.txt
  73. python scripts/make_sample_transcript.py --out ./demo-claude-projects --turns 14 --long-results
  74. python scripts/collect_sessions.py --claude-dir ./demo-claude-projects --data-dir ./demo-data --min-bytes 1000
  75. python scripts/normalize_sessions.py --data-dir ./demo-data
  76. python scripts/anonymize_sessions.py --data-dir ./demo-data --name "Taylor Quintrell"
  77. python scripts/build_dataset.py --data-dir ./demo-data --model Qwen/Qwen3.6-35B-A3B --max-len 8192 \
  78. --system-prompt-file assets/system-prompt.md
  79. python scripts/train_tinker.py --data-dir ./demo-data --name qwen3.6-35b-a3b-8k # offline smoke test
  80. ```
  81. The last command prints a decoded training row, the token count and the resolved
  82. configuration. Add `--train` to launch a real run; afterwards
  83. `export_checkpoint.py` and `make_gguf.sh` take it to a GGUF you can run.
  84. ## Then on your own sessions
  85. 1. Raise Claude Code's transcript retention first: `"cleanupPeriodDays": 3650` in
  86. `~/.claude/settings.json`. The default deletes sessions after 30 days.
  87. 2. Copy `.env.example` to `.env` and add your `TINKER_API_KEY` and `WANDB_API_KEY`.
  88. 3. Write `identity.json` (see `identity.example.json`): your usernames, full name,
  89. emails, handles, company, domains.
  90. 4. Follow `SKILL.md`, or let your agent drive. The decisions that stay yours: which
  91. projects to exclude, which model and context length, the system prompt and tool
  92. definitions of the harness you will serve in, and the learning rate when Tinker
  93. has no calibrated default.
  94. ## Install the skill
  95. Clone into your agent's skills directory. The directory name must be
  96. `tinker-ai-skill`, which `git clone` gives you by default:
  97. | Agent | Personal (all projects) | Project (this repo) |
  98. |---|---|---|
  99. | Claude Code | `~/.claude/skills/tinker-ai-skill/` | `.claude/skills/tinker-ai-skill/` |
  100. | OpenAI Codex | `~/.agents/skills/tinker-ai-skill/` | `.agents/skills/tinker-ai-skill/` |
  101. | OpenCode | `~/.config/opencode/skills/tinker-ai-skill/` | `.opencode/skills/tinker-ai-skill/` |
  102. ```
  103. # Claude Code
  104. git clone https://github.com/drost-ai/tinker-ai-skill.git ~/.claude/skills/tinker-ai-skill
  105. # Codex
  106. git clone https://github.com/drost-ai/tinker-ai-skill.git ~/.agents/skills/tinker-ai-skill
  107. # OpenCode
  108. git clone https://github.com/drost-ai/tinker-ai-skill.git ~/.config/opencode/skills/tinker-ai-skill
  109. ```
  110. OpenCode also reads `.claude/skills` and `.agents/skills`, so one project copy serves
  111. all three. Any other agent that supports the [Agent Skills](https://agentskills.io)
  112. standard works the same way. Invoke it directly with `/tinker-ai-skill` in Claude
  113. Code; Codex and OpenCode pick it up from its description.
  114. ## What it costs
  115. Tinker bills per token. Training cost is train tokens times the model's train price
  116. (see the [price list](https://tinker-docs.thinkingmachines.ai/tinker/models/models_and_pricing/));
  117. the smoke test prints the token count before you launch. Ballpark figures at
  118. November 2026 prices, one epoch of 64K rows:
  119. | Dataset | Train tokens | Qwen3.6-35B-A3B | Inkling 2 Small | Qwen3.8-27B |
  120. |---|---|---|---|---|
  121. | 100 rows (a personal corpus) | ~5M | ~$6 | ~$8 | ~$21 |
  122. | 1,000 rows (what our releases used) | ~45M | ~$55 | ~$70 | ~$185 |
  123. Dense models cost more per token than MoE models of similar quality (Tinker prices
  124. by active parameters); Qwen3.8-27B is the base of Tess-4.5.
  125. Sampling and periodic evaluation are extra and small. The dataset steps are free
  126. and run on your laptop.
  127. ## Requirements
  128. - Python 3.11+ and [uv](https://docs.astral.sh/uv/) (or pip)
  129. - `tinker-cookbook>=0.6.0` (installs `tinker`, `torch`, `tml-renderers`) and `wandb`
  130. - A [Tinker](https://tinker.thinkingmachines.ai) API key; a [Weights & Biases](https://wandb.ai/authorize) key is optional but recommended
  131. - Claude Code transcripts under `~/.claude/projects/` (other agents: emit the message
  132. schema in `references/claude-code-transcripts.md` and continue from step 2)
  133. - For steps 8-9: a built [llama.cpp](https://github.com/ggml-org/llama.cpp) checkout,
  134. and disk for the base model plus the merged copy
  135. ## Layout
  136. ```
  137. SKILL.md instructions the agent follows
  138. scripts/collect_sessions.py step 1
  139. scripts/normalize_sessions.py step 2a
  140. scripts/anonymize_sessions.py step 2b
  141. scripts/build_dataset.py steps 3-5
  142. scripts/train_tinker.py step 6
  143. scripts/sample_checkpoint.py step 7
  144. scripts/export_checkpoint.py step 8: download the LoRA, merge, optional PEFT adapter
  145. scripts/make_gguf.sh step 9: BF16 GGUF, quantize, mmproj, MTP draft
  146. scripts/serve_gguf.sh step 9: llama-server with training-matched flags
  147. scripts/make_sample_transcript.py synthetic transcript for a dry run
  148. scripts/common.py shared rendering (builder, trainer and sampler render identically)
  149. references/ format, anonymization, chunking, training, export and serving, lessons
  150. assets/system-prompt.md a generic agent system prompt to start from
  151. identity.example.json, .env.example
  152. ```
  153. ## Data safety
  154. `data/`, `demo-*/`, `runs/`, `export/`, `wandb/` and `.env` are git-ignored. The anonymizer
  155. fails rather than writing a file that still leaks. Review anonymized rows before
  156. training, and never publish a dataset built from transcripts that belong to someone
  157. else without their consent.
  158. ## Author and license
  159. Written by [Migel Tissera](https://huggingface.co/migtissera), creator of the Tess
  160. models. MIT license. Tinker and tinker-cookbook are products of Thinking Machines
  161. Lab; this skill is an independent guide built on them.
  162. If this saved you a failed training run, star the repository and share what you
  163. trained.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.