Instructions to use Aquiles-ai/Kairos-Initialized with libraries, inference providers, notebooks, and local apps. Follow these links to get started.

Libraries

How to use Aquiles-ai/Kairos-Initialized with Transformers:

# Use a pipeline as a high-level helper
from transformers import pipeline

pipe = pipeline("image-text-to-text", model="Aquiles-ai/Kairos-Initialized", trust_remote_code=True)
messages = [
    {
        "role": "user",
        "content": [
            {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/p-blog/candy.JPG"},
            {"type": "text", "text": "What animal is on the candy?"}
        ]
    },
]
pipe(text=messages)

# Load model directly
from transformers import AutoModel
model = AutoModel.from_pretrained("Aquiles-ai/Kairos-Initialized", trust_remote_code=True, device_map="auto")

Notebooks
Google Colab
Kaggle
Local Apps Settings

vLLM

How to use Aquiles-ai/Kairos-Initialized with vLLM:

Install from pip and serve model

# Install vLLM from pip:
pip install vllm
# Start the vLLM server:
vllm serve "Aquiles-ai/Kairos-Initialized"
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:8000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "Aquiles-ai/Kairos-Initialized",
		"messages": [
			{
				"role": "user",
				"content": [
					{
						"type": "text",
						"text": "Describe this image in one sentence."
					},
					{
						"type": "image_url",
						"image_url": {
							"url": "https://cdn.britannica.com/61/93061-050-99147DCE/Statue-of-Liberty-Island-New-York-Bay.jpg"
						}
					}
				]
			}
		]
	}'

Use Docker

docker model run hf.co/Aquiles-ai/Kairos-Initialized

SGLang

How to use Aquiles-ai/Kairos-Initialized with SGLang:

Install from pip and serve model

# Install SGLang from pip:
pip install sglang
# Start the SGLang server:
python3 -m sglang.launch_server \
    --model-path "Aquiles-ai/Kairos-Initialized" \
    --host 0.0.0.0 \
    --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "Aquiles-ai/Kairos-Initialized",
		"messages": [
			{
				"role": "user",
				"content": [
					{
						"type": "text",
						"text": "Describe this image in one sentence."
					},
					{
						"type": "image_url",
						"image_url": {
							"url": "https://cdn.britannica.com/61/93061-050-99147DCE/Statue-of-Liberty-Island-New-York-Bay.jpg"
						}
					}
				]
			}
		]
	}'

Use Docker images

docker run --gpus all \
    --shm-size 32g \
    -p 30000:30000 \
    -v ~/.cache/huggingface:/root/.cache/huggingface \
    --env "HF_TOKEN=<secret>" \
    --ipc=host \
    lmsysorg/sglang:latest \
    python3 -m sglang.launch_server \
        --model-path "Aquiles-ai/Kairos-Initialized" \
        --host 0.0.0.0 \
        --port 30000
# Call the server using curl (OpenAI-compatible API):
curl -X POST "http://localhost:30000/v1/chat/completions" \
	-H "Content-Type: application/json" \
	--data '{
		"model": "Aquiles-ai/Kairos-Initialized",
		"messages": [
			{
				"role": "user",
				"content": [
					{
						"type": "text",
						"text": "Describe this image in one sentence."
					},
					{
						"type": "image_url",
						"image_url": {
							"url": "https://cdn.britannica.com/61/93061-050-99147DCE/Statue-of-Liberty-Island-New-York-Bay.jpg"
						}
					}
				]
			}
		]
	}'

Docker Model Runner
How to use Aquiles-ai/Kairos-Initialized with Docker Model Runner:
```
docker model run hf.co/Aquiles-ai/Kairos-Initialized
```

Kairos-Initialized

⚠️ Experimental research artifact — NOT competent. This checkpoint comes from a series of experiments on how to build a small multimodal model from scratch. It is not a usable vision-language model. Do not use it in production, for automated decisions, or in any safety-critical context.

Overview

Kairos-Initialized is the assembled-but-untrained scaffold of Kairos, a research project exploring how to build a small multimodal model by combining an existing vision encoder, a lightweight projector, and a small LLM.

Vision tower: Aquiles-ai/MoonViT-3D, extracted from moonshotai/Kimi-K2.6. Frozen in every training stage.
Projector: Kimi-style 2-layer MLP (LayerNorm → Linear(4608→4608) → GELU → Linear(4608→2048)), randomly initialized, no alignment training applied.
LLM: LiquidAI/LFM2.5-2.6B.
Modality: image ↔ text only (no video).

The architecture, projector and processor follow the Kimi-K2.5/Kimi-K2.6 implementation on transformers 5.x.

Behavior

Text-only input: behaves like the base LFM2.5-2.6B. The projector is never touched, so the text-only prior is intact.
Image input: the random projector emits embeddings roughly 65× the norm of real text embeddings (no output cap is configured in this checkpoint). That injects disproportionately large vectors into a frozen LLM, so image-grounded output is garbage and unrelated to the actual image content.

Purpose

This checkpoint is the starting point of the training pipeline. It is used to:

Validate the plumbing (special tokens, embedding dimensions, forward/backward flow, frozen backbone).
Serve as the seed for the next experiment stages.

It exists because it was produced by the experiments, not because it is a usable model. See the progression:

Checkpoint	What changed	Status
Kairos-Initialized	Assembled architecture, random projector	Scaffold only
Kairos-Proj-80k	Projector aligned on 80k image-caption pairs (LLM frozen)	Not a usable VLM
Kairos-Alig-30k	Projector + LoRA(LLM) trained together on 30k reasoning samples	Early experiments, still not competent

Requirements

transformers >= 5.x (developed with 5.14.1)
trust_remote_code=True (the modeling code ships with the checkpoint)

Usage

import torch
from transformers import AutoModelForCausalLM, AutoProcessor

model_id = "Aquiles-ai/Kairos-Initialized"

model = AutoModelForCausalLM.from_pretrained(model_id, trust_remote_code=True, dtype=torch.bfloat16)
processor = AutoProcessor.from_pretrained(model_id, trust_remote_code=True)

messages = [{"role": "user", "content": "Hello!"}]
enc = processor.apply_chat_template(messages, tokenize=True, return_dict=True, return_tensors="pt", add_generation_prompt=True)
out = model.generate(**enc, max_new_tokens=64)

Limitations

Not competent for image understanding. Random projector, zero alignment.
Image inputs produce out-of-distribution embeddings (explosive norms) and incoherent output.
Only meaningful as the base scaffold of an experiment pipeline.

References

Blog post: Kairos: Building a Multimodal Model with LFM2.5 and Kimi-K2.6
Public repo: Aquiles-ai/Kairos
Training dataset: Aquiles-ai/LLaVA-CC3M-Pretrain-595K-Embedded
Reasoning dataset: Aquiles-ai/Kairos-Multimodal-Reasoning

License

This model card describes a research artifact assembled from third-party components (MoonViT-3D from Kimi-K2.6, LFM2.5-2.6B). Check each component's license before any use.