Convergent-7B

Convergent-7B

<p align="center"> <img src="convergent-banner.jpg" alt="Convergent-7B — bigcompute.science research companion" width="800"> </p>

The bigcompute.science research companion model.

Early Preview — This model is a work in progress, expressly trained to act as a research assistant with the bigcompute.science MCP server. We are still very early in the training process and the model will be updated frequently. Expect occasional bugs, incorrect tool calls, and hallucinated numerical values until we reach a GA release. If you encounter issues, please open an issue on the GitHub repo.

Convergent is part of the bigcompute.science conjecture-driven GPU research project. It is a QLoRA fine-tuned model designed to work as an agentic research companion — connecting to the bigcompute.science MCP server to reason about computational mathematics findings, write CUDA kernels, and suggest novel research directions for unsolved problems in number theory.

Capabilities

• Deep number theory knowledge: continued fractions, Zaremba's conjecture, Hausdorff dimensions, Kronecker coefficients, Ramsey numbers, Cohen-Lenstra heuristics, Flint Hills series
• CUDA kernel scaffolding: generates GPU kernel structure for number theory with architecture-specific flags (Ampere sm_86, Ada Lovelace sm_89, Hopper sm_90, Blackwell sm_100/sm_120) — output requires expert review for correctness
• Agentic tool calling: outputs Hermes-format <tool_call> blocks to query the bigcompute.science MCP server in ReAct loops
• Student guidance: provides specific, actionable advice for contributing to computational number theory at any level

Usage

from transformers import AutoModelForCausalLM, AutoTokenizer
import torch

model = AutoModelForCausalLM.from_pretrained("cahlen/Convergent-7B", dtype=torch.bfloat16, device_map="auto")
tokenizer = AutoTokenizer.from_pretrained("cahlen/Convergent-7B")

messages = [
    {"role": "system", "content": "You are Convergent, the bigcompute.science research companion. You specialize in computational mathematics, number theory, and GPU-accelerated experiments exploring unsolved conjectures."},
    {"role": "user", "content": "How does the Hausdorff dimension of E_{1,...,5} relate to Zaremba's conjecture?"}
]

text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
inputs = tokenizer(text, return_tensors="pt").to(model.device)

with torch.no_grad():
    outputs = model.generate(**inputs, max_new_tokens=512, do_sample=False)

response = tokenizer.decode(outputs[0][inputs["input_ids"].shape[1]:], skip_special_tokens=True)
print(response)

With Tool Calling (Agentic Mode)

Convergent uses the Hermes function-calling format. Pass tools via the tools= parameter on apply_chat_template — the tokenizer automatically injects the correct format instructions:

tools = [
    {"type": "function", "function": {"name": "get_zaremba_exceptions", "description": "Get the 27 Zaremba exceptions for A={1,2,3}", "parameters": {"type": "object", "properties": {}}}},
    {"type": "function", "function": {"name": "get_finding", "description": "Get full finding details", "parameters": {"type": "object", "properties": {"finding": {"type": "string"}}, "required": ["finding"]}}},
    {"type": "function", "function": {"name": "search_arxiv", "description": "Search arXiv for papers", "parameters": {"type": "object", "properties": {"query": {"type": "string"}}, "required": ["query"]}}}
]

messages = [
    {"role": "system", "content": "You are Convergent, the bigcompute.science research companion."},
    {"role": "user", "content": "What are the Zaremba exceptions for {1,2,3}?"}
]

text = tokenizer.apply_chat_template(messages, tools=tools, tokenize=False, add_generation_prompt=True)
inputs = tokenizer(text, return_tensors="pt").to(model.device)

with torch.no_grad():
    outputs = model.generate(**inputs, max_new_tokens=512, do_sample=False)

response = tokenizer.decode(outputs[0][inputs["input_ids"].shape[1]:], skip_special_tokens=True)
print(response)
# <tool_call>
# {"name": "get_zaremba_exceptions", "arguments": {}}
# </tool_call>

The full list of 23 MCP tools is available at mcp.bigcompute.science. You can fetch them dynamically:

import requests
resp = requests.post("https://mcp.bigcompute.science/", json={"jsonrpc": "2.0", "method": "tools/list", "params": {}, "id": 1})
mcp_tools = [{"type": "function", "function": t} for t in resp.json()["result"]["tools"]]

Using the CLI Toolkit (Recommended)

The easiest way to use Convergent with the MCP server:

git clone https://github.com/cahlen/convergent
cd convergent
pip install -r requirements.txt
./convergent agent

This automatically downloads the model from HuggingFace and starts an interactive agentic session that routes tool calls to mcp.bigcompute.science. To use a local model instead, set MERGED_MODEL_DIR=path/to/model.

Example Outputs

Real outputs from Convergent-7B to illustrate what the model can do.

Math Reasoning

Prompt: "How does the Hausdorff dimension of E_{1,...,5} relate to Zaremba's conjecture?"

The Hausdorff dimension δ(5) = dim_H(E_{1,...,5}) is the critical threshold: if δ(5) > 1/2, then almost every real number has a CF expansion with digits ≤ 5, which is exactly what Zaremba's conjecture predicts.

The connection: Zaremba's conjecture states that for every d ≥ 1, there exists a coprime a < d such that all partial quotients in the CF expansion of a/d are ≤ 5. This is equivalent to saying that the set of numbers with bounded CF digits has full Hausdorff dimension...

Agentic Tool Calling (Live MCP Server)

With the tools= parameter and all 23 MCP tools available:

Prompt: "What are the Zaremba exceptions for A={1,2,3}?"

<tool_call>
{"name": "get_zaremba_exceptions", "arguments": {}}
</tool_call>

After receiving the real MCP server response, the model reasons about the data:

The Zaremba exceptions for A={1,2,3} are: 6, 20, 28, 38, 42, 54, 96, 150, 156, 164, 216, 228, 318, 350, 384, 558, 770, 876, 1014, 1155, 1170, 1410, 1870, 2052, 2370, 5052, 6234. Verified to 10^10. Adding digit 4 eliminates 25 of these (only d=54 and d=150 remain). Adding digit 5 eliminates all 27.

Multi-Step Tool Chaining

When asked to "get the exceptions, then search arxiv for related recent work," the model chains tool calls naturally:

Step 1: get_zaremba_exceptions({})
  → "27 exceptions for A={1,2,3}, all below 6234. Let me now search
     for recent arXiv papers on Zaremba's conjecture."

Step 2: search_arxiv({"query": "Zaremba conjecture 2025 2026", "max_results": 5})
  → Synthesizes both results into a unified response

Error Recovery

When a tool call returns an error (e.g., "Finding not found: nonexistent-finding-xyz"), the model recovers gracefully:

"That finding doesn't exist. Let me check if there's a similar one." (proceeds to call a search tool as fallback)

Student Guidance

Prompt: "I'm a math undergrad interested in contributing to bigcompute.science. I know some Python but no CUDA. Where should I start?"

Phase 1 — 2 weeks: CUDA Basics

• Start with the NVIDIA CUDA C Programming Guide, chapters 1–3. Key concepts: threads, blocks, grids, memory hierarchy.
• Work through the "Hello World" kernel: print thread indices, block dimensions, grid dimensions.
• Compile with nvcc -arch=sm_XX hello.cu -o hello (replace XX with your GPU's architecture)...

Off-Topic Handling

Prompt: "What's the best recipe for chocolate cake?"

"I'm sorry, I can't answer that. I'm a research companion specializing in number theory and computational mathematics. I don't have expertise in baking or recipes."

Benchmarks

Custom Evaluation (103 questions, 20 categories)

Scores are from automated rubric evaluation with balanced category coverage (std = 8.4 across categories). CUDA code generation scores include real nvcc compilation testing and anti-pattern detection. The model is designed to work within agentic ReAct loops with the bigcompute.science MCP server.

Standard Benchmarks (Alignment Tax)

Math capabilities improved or preserved. General reasoning has a 6% tax — an acceptable trade-off for a specialized research model.

Training Details

Training Data Composition

• Curated domain blocks (~1,150 entries): 40+ modular blocks covering identity, tool calling (23 real MCP tools), nvcc-validated CUDA kernels, number theory, error recovery, paper comprehension, student guidance
• Synthetic CoT (Qwen2.5-Math-72B) (~3,100 entries): deep mathematical reasoning generated on NVIDIA H200
• Synthetic reasoning (Gemma-4-26B) (~1,200 entries): creative synthesis and experiment design
• External (Hermes FC dataset) (300 entries): diverse tool-calling patterns from NousResearch

Data has been cleaned of off-topic entries and deduplicated (97 entries removed from raw merge).

See the dataset card for full composition details and DATA_SOURCES.md for source documentation.

The Research Flywheel

Convergent is continuously updated as bigcompute.science produces new findings:

GPU Computation → Findings → Train into Model → Reason & Discuss → New Experiments
     ↑                                                                    │
     └────────────────────────────────────────────────────────────────────┘

The training toolkit is open-source: github.com/cahlen/convergent

Limitations

• Not a theorem prover: Can suggest proof strategies but cannot produce formal proofs
• May hallucinate specific numbers: Always verify computational claims against the MCP server
• CUDA code requires review: The model generates structurally correct CUDA kernels but may contain logical errors, incorrect mathematical implementations (e.g., inverted conjecture checks), compilation issues (host-only functions in device code), and race conditions. Treat generated kernels as scaffolding that requires expert validation before execution
• Specialized domain: Optimized for number theory and GPU computation, not general-purpose assistance
• Training data cutoff: Knowledge is current to the last training cycle

Citation

@misc{humphreys2026convergent,
  author = {Humphreys, Cahlen},
  title = {Convergent: A QLoRA-tuned Research Companion for Computational Number Theory},
  year = {2026},
  url = {https://github.com/cahlen/convergent}
}

Links

• bigcompute.science — Conjecture-driven GPU research in computational mathematics
• MCP Server — Model Context Protocol server for experimental data and tools
• Training Toolkit — Full pipeline source code on GitHub
• Training Data — Complete training dataset on HuggingFace
• guerrillamathematics.com — Mathematical research blog

---

This project is maintained by a single person. If you run into issues, please file them on GitHub or HuggingFace and I will do my best to address them. I apologize in advance for any delays in response time.