Kairos-7B-CIDA-v1.0

<div align="center">

Kairos-CIDA-7B

The Reasoning Adapter That Changes Everything

Same 7B backbone. 2× faster. No chain-of-thought. Better accuracy.

</div>

---

The Problem With Every Other Model

Every reasoning model today — o1, DeepSeek-R1, Qwen-thinking — generates reasoning as visible text tokens before answering. That means:

• You pay for hundreds of reasoning tokens you never asked for
• Generation is slow because every thinking step is autoregressive
• The reasoning process is hardcoded into the output format

Kairos-CIDA does none of that.

Reasoning happens entirely inside the model before the first output token is generated. No visible thinking. No extra tokens. No slowdown from verbose chain-of-thought. Just a better answer, faster.

---

Numbers First

GSM8K — Grade School Mathematics

Kairos-CIDA achieves 55.4% without generating a single reasoning token. The backbone alone, using the same greedy generation, scores 8% under the same no-CoT protocol. That is a +47.4 percentage point gain from 160M parameters.

HumanEval — Python Code Synthesis

ARC-Challenge — Scientific Reasoning

MBPP — Python Task Completion

---

Speed

One of the most important properties of Kairos-CIDA is what it does not generate.

Kairos-CIDA generates a direct answer — not a thinking trace — and still beats the base model accuracy by a wide margin. Compared to CoT generation, it is approximately 2× faster and uses roughly 50% fewer tokens.

At production scale this translates directly to infrastructure cost reduction.

---

Why This Matters

Against the backbone

The Qwen1.5-7B-Chat backbone with standard chain-of-thought scores 62.5% on GSM8K. Kairos-CIDA uses the same frozen backbone — not a single weight changed — and without generating any reasoning tokens, reaches 55.4% using our protocol, and competes on the same level without the CoT tax.

Against larger models

Kairos-CIDA at 7B + 160M trainable parameters outperforms models that are 10× larger on specific reasoning and code tasks. It does this without fine-tuning the backbone, without LoRA, and without any modification to the base model weights.

Against LoRA and full fine-tuning

LoRA modifies the backbone. Full fine-tuning replaces it. Kairos-CIDA leaves it completely untouched. That means:

• The base model can be updated independently
• The adapter is portable across backbone versions
• There is no risk of degrading the backbone's general capabilities

---

v1 → v2: The Alignment Tax Problem, Solved

Kairos-CIDA v1 was a math and logic specialist. Applying it to code tasks caused accuracy to drop — the reasoning mechanism was pulling the model away from code formatting. This is a known problem in adapter research: improving one skill degrades another.

v2 solved this completely.

Math accuracy increased from 42% to 55.4% while coding benchmarks went from near-zero to 100% syntax compliance. The two capabilities are now additive, not competitive.

The technical approach behind this is proprietary. The results are public.

---

What It Can Do

Kairos-CIDA is a single adapter that covers three domains without task-specific configuration:

Mathematics — Multi-step arithmetic, algebra, word problems, grade-school through competition-level reasoning.

Python Code — Function synthesis, algorithm implementation, debugging, competitive programming at introductory level.

Logic and Science — Multiple-choice scientific reasoning, deductive logic, causal inference.

Same model. Same weights. No prompt engineering required beyond specifying the domain.

---

Quickstart

pip install cida-plugin

import torch
import torch.nn as nn
from transformers import AutoTokenizer, AutoModelForCausalLM
from cida_plugin import CIDAPlugin, CIDAPluginConfig

DEVICE = "cuda"

# Frozen backbone — nothing here is ever modified
tokenizer = AutoTokenizer.from_pretrained(
    "Qwen/Qwen1.5-7B-Chat", trust_remote_code=True, padding_side="left"
)
if tokenizer.pad_token is None:
    tokenizer.pad_token = tokenizer.eos_token

llm = AutoModelForCausalLM.from_pretrained(
    "Qwen/Qwen1.5-7B-Chat", trust_remote_code=True,
    torch_dtype=torch.float16, device_map="auto", output_hidden_states=True,
)
for p in llm.parameters():
    p.requires_grad = False
llm.eval()

# Load Kairos-CIDA adapter
cida_cfg = CIDAPluginConfig.from_pretrained("Kairatzh/Kairos-CIDA-7B")
cida     = CIDAPlugin(cida_cfg)
import torch; sd = torch.load("pytorch_model.bin", map_location="cpu")
cida.load_state_dict(sd)
cida = cida.to(DEVICE).float().eval()

# See the full inference example in the repository notebooks

Full inference code, training notebooks, and the benchmark evaluation suite are available at github.com/Kairatzh/CIDA-plugin.

---

Model Files

---

Citation

@misc{kairos-cida-2025,
  title        = {Kairos-CIDA-7B: Latent Reasoning Adapter for Frozen LLMs},
  author       = {Kairatzh},
  year         = {2025},
  howpublished = {\url{https://huggingface.co/kirtzh/Kairos-CIDA-7B-v1.0}},
  note         = {Repository: https://github.com/Kairatzh/CIDA-plugin}
}

---

License

Apache 2.0. The backbone model (Qwen1.5-7B-Chat) is subject to its own license terms at the Qwen model page.