C1-Tachu

C1-Tachu

C1-Tachu is a specialized coding AI fine-tuned from Qwen2.5-Coder-14B with a single mission: minimize the time from prompt to production-ready software.

The model is not optimized for benchmark scores. It is optimized for developer throughput — fewer iterations, faster debugging, faster code navigation, faster architecture decisions, and faster project completion.

Model Details

Training

C1-Tachu was trained using QLoRA (4-bit nf4 quantization with LoRA adapters) via the Axolotl framework on AWS g5.2xlarge (NVIDIA A10G).

Pipeline (8 stages)

Each stage trains a fresh LoRA adapter on the previous stage's merged model, then merges it back into the base weights. Adapters are not stacked — each stage builds cleanly on the merged result.

Stage 7 (ORPO) was skipped in this training run due to time constraints. The model retains all capabilities from stages 1–6 and 8.

QLoRA Hyperparameters

Capabilities

C1-Tachu is trained across six skill domains:

1. Software Foundation — Broad code familiarity across languages and patterns, calibrated to a terse, correct response style
2. Fast Code Generation — Produces correct implementations with minimal tokens; no unnecessary comments or padding
3. Debugging Speed — Jumps to root cause instead of enumerating possibilities; trained on real GitHub commit-fix pairs
4. Project Navigation — Answers "where" and "how" questions about unfamiliar repos without reading every file
5. Rapid Architecture — Compresses the planning→coding loop: requirements → architecture → plan → code skeleton
6. Self Verification — Agent loop with tool use (run_tests, compile, read_file, write_file, run_command) to reach working solutions with minimal human intervention
7. Agent Workflows — Complex multi-step task decomposition with parallel tool calls

Quickstart

from transformers import AutoModelForCausalLM, AutoTokenizer

model_name = "Pomoika24/C1-Tachu"

tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
    model_name,
    torch_dtype="auto",
    device_map="auto",
)

messages = [
    {"role": "system", "content": "You are Tachu, a fast software engineer."},
    {"role": "user", "content": "Implement a retry wrapper with exponential backoff in Python."},
]

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

generated_ids = model.generate(
    **model_inputs,
    max_new_tokens=2048,
)
response = tokenizer.decode(generated_ids[0][len(model_inputs.input_ids[0]):], skip_special_tokens=True)
print(response)

Deployment with vLLM

pip install vllm
vllm serve "Pomoika24/C1-Tachu"

Deployment with Ollama

ollama run hf.co/Pomoika24/C1-Tachu

Security Posture

Stance: passive (do no harm).

• Never generates known-vulnerable patterns: hardcoded secrets, SQL injection, command injection, path traversal, XSS, insecure deserialization, disabled auth checks
• Defaults to safe patterns: parameterized queries, input validation, proper error handling without leaking stack traces
• Does not actively scan code for vulnerabilities unless explicitly asked for a security review
• Does not refuse to work on codebases with existing vulnerabilities — just doesn't make them worse
• When uncertain, prefers the safer pattern even if more verbose

Limitations

• Stage 7 (ORPO) not trained — the model has not undergone preference optimization, so it may produce verbose solutions where a shorter one would suffice
• Training data not published — the dataset was generated on cloud infrastructure and is not publicly available
• Single-annotator evaluation — eval sets were scored by one developer with LLM-as-judge assistance; no multi-annotator agreement metrics
• Context limit — while the base model supports 32K context, training stages used 2048–4096 token sequences; performance may degrade on very long contexts
• English-focused — training data is predominantly English

Intended Use

C1-Tachu is designed for:

• Software engineers looking to accelerate their workflow
• Coding agents and assistants that need fast, correct code generation
• Automated debugging and code navigation tasks
• Architecture planning and code scaffolding

Not intended for:

• Automated security auditing (passive stance only)
• Code generation in safety-critical systems without human review
• Production deployment without human oversight

Citation

@misc{c1-tachu,
  title={C1-Tachu: A Speed-Optimized Coding AI},
  author={Vladislav Kondratyev},
  year={2026},
  url={https://huggingface.co/Pomoika24/C1-Tachu}
}