elephant-embeddings-text-small

Why it fits agentic workloads

Agentic systems do not call embeddings once. They call them everywhere: before retrieval, during routing, when matching tools, when searching memory, and while compressing or re-ranking state. That means a useful agent embedding model must be more than accurate — it must also be flexible under tight runtime budgets.

elephant-embeddings-v1-text-small is designed around that reality.

1. One model, many budget tiers

This model supports Matryoshka embeddings, which means you can encode once at full size and truncate to smaller dimensions with limited quality loss.

That is especially useful for agent systems because different stages of the stack often need different budgets:

• 64d for very cheap candidate generation, broad routing, or huge memory banks
• 256d for balanced retrieval over large corpora
• 768d for highest-quality retrieval, offline indexing, or final-stage matching

Instead of managing separate embedding models for each tier, you can keep one semantic space and choose the dimensional budget that matches the task.

2. 2D Matryoshka gives runtime flexibility, not just storage savings

The model is trained with 2D Matryoshka behavior:

• dimension reduction for smaller vectors and lower storage / bandwidth cost
• layer reduction for lower-latency inference paths in custom runtimes

This matters for agents because the same system often mixes:

• latency-sensitive routing decisions
• high-volume memory scans
• higher-quality retrieval for final evidence gathering

A single model that can serve multiple latency / quality profiles is much easier to operate than a stack of unrelated specialized encoders.

3. Long context helps when agent state is not naturally short

Many agent workloads are not short isolated queries. They involve:

• tool descriptions
• execution traces
• long notes
• merged memory summaries
• multi-hop research snippets
• large document chunks

With 32,768 tokens of context length, elephant-embeddings-v1-text-small can represent larger semantic units before you are forced into aggressive chunking. That helps preserve cross-section meaning in long documents and richer memory entries.

4. Small enough to be operationally practical

At roughly 307M parameters, this model sits in a useful middle ground:

• substantially lighter than large embedding models in the 600M+ or multi-billion range
• still expressive enough for multilingual retrieval and similarity work
• easier to host in systems where embedding is part of a hot path rather than an occasional offline batch

For agentic platforms, that usually means better economics and simpler scaling.

5. One embedding space across the stack

Agent systems are easier to operate when routing, retrieval, memory search, and semantic matching all live in the same vector space.

elephant-embeddings-v1-text-small is well suited to that pattern:

• 64d can serve broad routing and large-memory scanning
• 256d can cover the main retrieval tier
• 768d can stay reserved for the highest-fidelity matching paths

That means one model can cover multiple semantic stages without forcing the system to juggle incompatible encoders, duplicated indexes, or divergent retrieval behavior.

Model at a glance

Headline results

These numbers make the model particularly attractive for systems that must balance quality, latency, vector size, and deployment simplicity instead of optimizing only for leaderboard peak score.

Usage

Basic usage with Sentence Transformers

from sentence_transformers import SentenceTransformer

model = SentenceTransformer("/path/to/elephant-embeddings-v1-text-small")

texts = [
    "Find tool descriptions related to browser automation.",
    "检索和用户历史偏好相关的记忆。",
    "Retrieve notes about deployment failures in staging.",
]

embeddings = model.encode(texts)
print(embeddings.shape)  # (3, 768)

Matryoshka truncation for smaller vectors

import torch.nn.functional as F
from sentence_transformers import SentenceTransformer

model = SentenceTransformer("/path/to/elephant-embeddings-v1-text-small")
embeddings = model.encode(texts, convert_to_tensor=True)

# Balanced retrieval tier
embeddings_256d = F.normalize(embeddings[:, :256], p=2, dim=1)

# Ultra-cheap routing / large memory-bank tier
embeddings_6