makeitwork-1 (v13)

A 500M parameter decoder-only transformer (LLaMA-style architecture) fine-tuned for codebase information retrieval with multi-hop search reasoning and tool-calling.

Model Details

• Architecture: Retriever500M (custom LLaMA-style decoder)
• Parameters: ~497M
• Hidden dim: 1,280
• Layers: 23
• Attention heads: 20
• FFN dim: 3,456 (SwiGLU)
• Positional encoding: RoPE
• Normalization: RMSNorm
• Tied embeddings: Yes
• Vocab size: 32,009 (with special tokens)
• Checkpoint: sft_v13 (step 1000, EMA loss 0.1500)

Capabilities

The model acts as an autonomous code search agent. Given a natural language query about a codebase, it:

1. Reasons about the query using <|reasoning|> to decompose it into subqueries
2. Searches the codebase using <|search|> tokens — can perform multi-hop search (search → inspect results → refine search)
3. Analyzes <|result|> blocks returned by the retrieval system
4. Returns curated <|evidence|> with the relevant code snippet, file path, and symbol name
5. Terminates cleanly with <|finish|>

The multi-hop capability allows the model to handle vague queries (e.g. "find a function that does something"), indirect queries (e.g. "function that calls X", "function involving testing"), and stemmed queries (e.g. "function involving parsing" → searches "parse") by first searching a broad keyword, extracting the specific symbol name from the results, and then searching for that exact name.

Special Tokens

Benchmark: Code Search Eval v5

Overview

The model is evaluated on a held-out test set of 50 code search queries spanning multiple programming languages and query types. The eval set was constructed from 20 open-source repositories covering Python, Rust, Go, C, TypeScript, Java, and JavaScript.

Query Types

The benchmark includes the following query categories, designed to test different aspects of code search:

Evaluation Protocol

Each query is evaluated by running the full agent loop:

1. The model receives the system prompt + user query
2. It generates tokens autoregressively (greedy decoding)
3. When it emits <|search|>...<|end|>, a retrieval result is injected as <|result|>...<|end|>
4. The model can perform up to 3 search hops (multi-hop reasoning)
5. Generation continues until <|finish|> or max 600 tokens

Metrics

Results (v13)

Progression Across Training Rounds

Remaining Failure Modes (4/50)

The 4 remaining failures at 92% accuracy fall into two categories:

1. Multi-hop not executed (3 cases): The model correctly identifies the target symbol name in its reasoning but goes to <|evidence|> instead of issuing a second <|search|>. This affects vague queries ("Where is the function defined?") and indirect queries ("function returns builder.startObject").

2. Character-level near-miss (1 case): The model performs two searches but both are near-misses of the target name (test_establish_connection_using_3_types vs expected test_establish_connection_using_3_levels_config).

Training

Dataset

• Dataset version: v11 (192,703 traces)
• Source code: 628,100 code chunks from 20 open-source repositories
• Trace types:
  • Multi-hop vague queries (15K) — search generic keyword → extract name → search name
  • Multi-hop returns/calls queries (28K) — search called method → extract caller → search caller
  • Multi-hop stemming queries (7K) — "involving testing" → search "test" → extract name → search name
  • Multi-hop involving queries (7K) — search keyword → extract name → search name
  • Near-miss discrimination (8K) — search wrong name → compare suffixes → search correct name
  • Code-to-name extraction (8K) — extract function name from code snippet → search it
  • Exact copy (44K) — single-hop: search exact name from query
  • Inherited from v10 (137K) — prior multi-hop + single-hop traces

Training Configuration

• Method: Supervised Fine-Tuning (SFT)
• Base checkpoint: sft_v12 (90% accuracy)
• Optimizer: AdamW (betas=0.9, 0.95, weight_decay=0.1)
• Learning rate: 5e-5 with cosine schedule
• Batch size: 4 (effective 32 with gradient accumulation 8)
• Sequence length: 1024
• Precision: BF16
• Gradient clipping: 1.0
• Steps: 1000
• Hardware: NVIDIA H100 80GB
• Training time: ~21 minutes
• Final EMA loss: 0.1500

Training Progression

The model was trained iteratively across 7 SFT rounds (v6→v8→v9→v10→v11→v12→v13), with each round:

1. Analyzing remaining failures from the previous checkpoint
2. Generating targeted training traces for those failure modes
3. Fine-tuning from the previous checkpoint (warm start)
4. Re-evaluating on the held-out test set

Usage

import torch
import sys
sys.path.insert(0, ".")  # model.py in repo root

from model import ModelConfig, Retriever500M
from safetensors.torch import load_file
from tokenizers import Tokenizer

# Load config
import json
with open("config.json") as f:
    cfg = json.load(f)

config = ModelConfig(
    vocab_size=cfg["vocab_size"],
    d_model=cfg["d_model"],
    n_layers=cfg["n_layers"],
    n_heads=cfg["n_heads"],
    d_ff=cfg["d_ff"],
    max_seq_len=cfg["max_seq_len"],
    dropout=0.0,
    tie_embeddings=True,
)

model = Retriever500M(config)
state_dict = load_file("model.safetensors")
model.load_state_dict(state_dict)
model.eval()

tokenizer = Tokenizer.from_file("tokenizer_agent.json")

Agent Loop Example

# System prompt
SYSTEM = (
    "You are a code search agent. Given a query from a reasoning model, "
    "decompose it into subqueries, search the codebase, inspect results, "
    "and return curated evidence. Use <|search|> to issue searches, "
    "<|reasoning|> to analyze, and <|evidence|> to return findings. "
    "Be concise. Extract only the relevant facts. End with <|finish|>."
)

# Build input: [system] SYSTEM [end] [user] "Find parseBoolean" [end] [assistant]
# Then generate autoregressively, injecting retrieval results after each <|search|>...<|end|>

License

MIT