Cognitivess-1

Cognitivess-1 is a frontier reasoning and coding model from CognitivessAI, built for long-horizon agentic work, software engineering, and graduate-level reasoning. It is tuned to perform reliably in real tool-using environments — terminals, codebases, web search — while staying strong on pure-reasoning math and science benchmarks.

• Languages: Romanian, English
• Pipeline: Text generation (chat / instruct / agentic)
• License: cognitivessai (see LICENSE)
• Website: https://cognitivess.com

Intended uses

• Agentic coding and terminal workflows (multi-step tool use, file editing, repo-level changes).
• Complex reasoning over mathematics, the sciences, and graduate-level QA.
• Multilingual assistance, with native Romanian and English support.

Evaluation results

All scores are reported as percentages. Cognitivess-1 results were measured by CognitivessAI. Competitor values are taken from their published model cards / announcements; values marked ~ are read visually from the benchmark chart (no numeric label on the bar) and n/a means the model was not reported on that benchmark.

Benchmark	Cognitivess-1	Claude Fable 5	Claude Opus 4.8	GPT-5.5	Gemini 3.1 Pro
AIME 2026	99.2	n/a	~96	~98	~98
GPQA-Diamond	91.2	~93	~93	~93	~94
HLE (w/ tools)	54.7	~53	~58	~52	~51
HMMT Nov 2025	94.4	n/a	~96	~96	~95
SWE-bench Pro	81.0	~80	~69	~58	~54
Terminal-Bench 2.1	83.0	n/a	~85	~84	~74

Benchmark notes

Benchmark	What it measures	Dataset
AIME 2026	Competition mathematics (American Invitational Mathematics Examination).	MathArena/aime_2026
GPQA-Diamond	Graduate-level, "Google-proof" science QA (biology, physics, chemistry), diamond subset.	Idavidrein/gpqa (diamond)
HLE (w/ tools)	Humanity's Last Exam — frontier expert knowledge across math, humanities, natural sciences; evaluated with tools.	cais/hle
HMMT Nov 2025	Harvard-MIT Mathematics Tournament (November 2025).	MathArena/hmmt_nov_2025
SWE-bench Pro	Real-world GitHub issue resolution in production repositories.	ScaleAI/SWE-bench_Pro
Terminal-Bench 2.1	Agentic task completion in containerized terminal environments.	Terminal-Bench

Training details

Architecture

Cognitivess-1 uses a custom Cognitivess architecture that combines several efficiency-focused mechanisms for long-context, high-throughput generation:

• Multi-head Latent Attention (MLA) — low-rank projection of the query and KV states to compress the KV cache and support very long contexts.
• Mixture of Experts (MoE) — routed experts plus a shared expert, with top-k routing per token, keeping the active cost per token far below the model's total capacity.
• Sparse indexed attention + IndexShare — attention is routed through a learned sparse index rather than computed over the full context, giving sub-quadratic scaling over long sequences.
• Tied input/output embeddings.

Because this architecture is not yet part of the upstream transformers library, Cognitivess-1 is shipped as remote code (trust_remote_code=True), exposing CognitivessForCausalLM, CognitivessModel, and CognitivessConfig — the same mechanism other custom-architecture models on the Hub use.

Methodology

Cognitivess-1 was fine-tuned with QLoRA (parameter-efficient fine-tuning): the base weights are held in 4-bit quantization while low-rank adapters are trained, keeping the full model loadable and trainable within a single multi-GPU node. Trained adapters are merged back into the base weights in BF16 before publishing, so the released checkpoint is a standard merged model — no adapter is required at inference.

The training data carries a separate reasoning_content field alongside the final response. This is mapped to the model's native reasoning channel, so Cognitivess-1 learns to emit structured reasoning before committing to an answer — the same channel exposed in the API as reasoning_content and as Anthropic-style thinking blocks.

Hardware

Training ran on 8× NVIDIA H200 with FSDP sharding and SDPA attention (attn_implementation="sdpa").

Training data

Cognitivess-1 was trained on a curated, proprietary mix of reasoning, code, and agentic SFT traces spanning mathematics, software engineering, and multi-step tool use. Training data details are not publicly released.

Limitations and ethical considerations

• Benchmark scores, especially agentic ones (SWE-bench Pro, Terminal-Bench), are sensitive to harness configuration, tool availability, and compute budget; cross-model comparisons should account for differing evaluation setups.
• Values marked ~ are visual estimates, not exact reported figures.
• The model can produce incorrect or outdated information; verify safety-critical output.
• Intended for authorized, lawful use cases. Not for generating harmful, malicious, or deceptive content.

How to use

Cognitivess-1 is served through an OpenAI- and Anthropic-compatible API. Install the official Python SDK:

pip install cognitivess

Generate an API key in your CognitivessAI dashboard (looks like ssh-ed25519 AAAA..., shown only once), then either pass it explicitly or export it:

export COGNITIVESS_API_KEY="ssh-ed25519 AAAA..."

OpenAI style — chat completions

from cognitivess import Cognitivess

cog = Cognitivess()  # reads COGNITIVESS_API_KEY

resp = cog.chat.completions.create(
    model="Cognitivess-1",
    messages=[
        {"role": "system", "content": "You are a helpful assistant."},
        {"role": "user", "content": "Hello, how are you?"},
    ],
)
print(resp.choices[0].message.content)

Anthropic style — messages

msg = cog.messages.create(
    model="Cognitivess-1",
    max_tokens=128,
    system="You are a helpful assistant.",
    messages=[{"role": "user", "content": "Hello!"}],
)
print(msg.content[0].text)

Streaming (async)

import asyncio
from cognitivess import AsyncCognitivess

async def main():
    async with AsyncCognitivess() as cog:
        async for chunk in cog.chat.completions.create(
            model="Cognitivess-1",
            messages=[{"role": "user", "content": "Count to 5."}],
            max_tokens=64,
            stream=True,
        ):
            delta = chunk.choices[0].delta.content
            if delta:
                print(delta, end="", flush=True)

asyncio.run(main())

The SDK also supports structured outputs (response_format), the Responses API (cog.responses.create), streaming SSE, typed exceptions, retries with backoff, and timeout control. Self-hosted or dev? Override the base URL:

cog = Cognitivess(base_url="https://api.cognitivess.com/v1")

Full reference: https://api.cognitivess.com/docs

Citation

@misc{cognitivess1,
  title  = {Cognitivess-1},
  author = {CognitivessAI},
  year   = {2026},
  url    = {https://cognitivess.com}
}