Zyn Dwarf 1.0

Small by design. Capable by nature.

Zyn Dwarf 1.0 is a lightweight conversational language model developed and packaged by Zyn’s Labs. It is built from the Liquid AI LFM2.5-350M family and refined with a small LoRA adaptation focused on coding-response structure, model identity, and practical assistant behavior.

The project is intentionally small: the published GGUF uses Q4_K_M quantization and is roughly 219 MiB on disk, while the Ollama package is roughly 229 MB including its additional model metadata/configuration layers.

Zyn Dwarf is designed for local inference, lightweight assistants, coding-oriented conversations, tool-oriented workflows, and environments where a multi-billion-parameter model would be unnecessarily expensive.

---

Table of Contents

1. Overview
2. At a Glance
3. What Zyn Dwarf Is
4. Model Lineage
5. Architecture
6. Technical Specifications
7. Capabilities
8. Tool Calling
9. Coding Behavior
10. Identity
11. Context Length
12. Quantization and Footprint
13. Resource Profile
14. How the Model Was Adapted
15. What Was Intentionally Not Changed
16. Comparison With Other Small Models
17. Comparison With Its Upstream Model
18. Capabilities Comparison
19. Performance Testing
20. Benchmark Policy
21. Recommended Use Cases
22. Not Recommended For
23. Current-Information and 2026 News
24. Ollama
25. Ollama Configuration
26. Using the Model
27. Tool Calling Example
28. Model Tags and Capabilities
29. Limitations
30. Safety and Reliability
31. Licensing
32. Attribution
33. Model Files
34. Integrity
35. Reproducibility
36. Versioning
37. FAQ
38. Roadmap
39. Credits
40. Sources

---

Overview

Zyn Dwarf 1.0 is a deliberately compact model. The goal is not to compete with large frontier systems on every benchmark. The goal is to provide a useful assistant while keeping the model inexpensive to store, load, and run locally.

The project prioritizes:

• Very small storage footprint.
• Low memory requirements relative to larger local models.
• Fast local generation on modest hardware.
• Conversational responses.
• Practical coding assistance.
• Structured explanations for programming questions.
• Tool-oriented workflows.
• Simple integration through Ollama and GGUF.
• Minimal additional behavioral tuning.
• Preservation of the underlying model’s general capabilities.

The upstream LFM2.5 family is specifically designed for on-device deployment. Liquid AI describes LFM2.5-350M as a 350M-parameter general-purpose text model with 16 layers, a 65,536-token vocabulary, and a documented 32,768-token context length. Liquid AI also describes the family as suitable for edge and on-device applications.
Source: https://huggingface.co/LiquidAI/LFM2.5-350M

---

At a Glance

Property	Zyn Dwarf 1.0
Model name	Zyn Dwarf 1.0
Organization	Zyn’s Labs
Upstream family	Liquid AI LFM2.5
Upstream model	LFM2.5-350M
Parameters	~354.5M
Architecture	LFM2
Layers	16
Vocabulary	65,536
Format	GGUF
Published quantization	Q4_K_M
GGUF size	~219 MiB
Ollama package size	~229 MB
Configured Ollama context	32,768 tokens
Runtime metadata context	128,000 max-position metadata is present in the GGUF
Ollama capabilities	Completion, Tools
Vision	No
Audio	No
Image generation	No
Embeddings	No
Reranking	No
Thinking mode	No dedicated separate mode
Primary languages	General multilingual base; Zyn’s coding behavior is primarily tested in English
Main focus	Lightweight chat, coding, tools
Slogan	Small by design. Capable by nature.

---

What Zyn Dwarf Is

Zyn Dwarf 1.0 is a derived and adapted model, not a model trained from scratch by Zyn’s Labs.

Its foundation comes from Liquid AI’s LFM2.5-350M family. Zyn’s Labs adds a small behavioral adaptation and the packaging required to distribute the resulting model as Zyn Dwarf.

This distinction matters.

Zyn’s Labs is responsible for:

• The Zyn Dwarf identity.
• The name and organization metadata.
• The additional lightweight behavioral adaptation.
• Coding-response formatting behavior.
• Zyn-specific packaging.
• Ollama configuration.
• Publication metadata.
• Documentation.

Liquid AI remains the upstream creator of the LFM2.5 architecture and original model weights.

---

Model Lineage

Liquid AI
└── LFM2.5 family
    └── LFM2.5-350M
        └── lightweight LoRA adaptation
            └── merged checkpoint
                └── GGUF conversion
                    └── Q4_K_M quantization
                        └── Zyn Dwarf 1.0
                            └── Ollama package
                                └── itsZyn/ZynDwarf-1.0

The adaptation is intentionally narrow. It is not intended to replace the original model’s knowledge or redesign its architecture.

---

Architecture

Zyn Dwarf uses the LFM2 architecture.

Liquid AI’s published configuration identifies the model as lfm2 and Lfm2ForCausalLM. The 350M model has:

• 16 hidden layers.
• 10 convolution-style blocks.
• 6 attention blocks.
• 16 attention heads.
• 8 key/value heads in its grouped-query attention structure.
• 1,024-dimensional hidden representations.
• 65,536 vocabulary entries.

Source: https://huggingface.co/LiquidAI/LFM2.5-350M

The hybrid design is one reason the family can target edge and on-device deployment. It is not simply a reduced-size copy of a conventional large Transformer.

---

Technical Specifications

Core Parameters

Specification	Value
Parameter count	354,483,968
Approximate label	354M
Hidden size	1,024
Number of layers	16
Vocabulary	65,536
Architecture	LFM2
Model type	Causal language model
Upstream precision	BF16
Published local format	GGUF
Published quantization	Q4_K_M

Liquid AI’s model configuration reports a parameter count of 354,483,968 and 16 hidden layers.
Source: https://huggingface.co/LiquidAI/LFM2.5-350M/config.json

---

Capabilities

Ollama capabilities

The current Ollama package reports:

Capabilities
  completion
  tools

This was verified directly with the installed Ollama runtime.

Capability matrix

Capability	Zyn Dwarf 1.0	Status
Text completion	Yes	Supported
Chat	Yes	Supported
Tool calling	Yes	Supported
Function calling	Yes	Supported through tool interface
Coding assistance	Yes	Adapted behavior
Code explanation	Yes	Adapted behavior
Python	Yes	Intended
JavaScript	Yes	Intended
TypeScript	Yes	Intended
Vision	No	Not a multimodal model
Image understanding	No	Not supported
Image generation	No	Not supported
Audio input	No	Not supported
Speech synthesis	No	Not supported
Embeddings	No	Not the intended runtime
Reranking	No	Not the intended runtime
Dedicated thinking mode	No	Not provided as a separate capability
Live web knowledge	No	Requires external tools

---

Tool Calling

Tool calling is one of the most important parts of the Zyn Dwarf packaging.

Ollama supports tool calling by passing a tool list through its API and returning tool calls in the assistant response.
Source: https://ollama.com/blog/tool-support

Zyn Dwarf’s LFM2-compatible chat template contains the tool markers expected by the model:

<|tool_list_start|>
<|tool_list_end|>

<|tool_call_start|>
<|tool_call_end|>

<|tool_response_start|>
<|tool_response_end|>

The template also handles:

• Tool definitions.
• Tool responses.
• Assistant tool calls.
• Multiple tool calls.
• Tool-call arguments.

Ollama detects the resulting model as having the tools capability.

Important distinction

A model supporting tool calling does not mean the model can browse the web by itself.

Tools are external capabilities supplied by the application.

For example:

Zyn Dwarf
   |
   +--> get_weather()
   |
   +--> search_web()
   |
   +--> read_file()
   |
   +--> run_code()
   |
   +--> database_query()

The application owns those functions. Zyn Dwarf generates the requested call; the host application executes the tool and supplies the result.

---

Coding Behavior

Zyn Dwarf was given a very small behavioral adaptation focused on the organization of programming responses.

The intended structure is:

1. Introduction
2. Explanation
3. Code
4. Closing note

Example structure

Sure, I can help you create a Python function that adds two numbers.

This function receives two values and returns their sum.

```python
def add_numbers(a, b):
    return a + b

You can call it with two numbers whenever you need their sum.

The training objective was intentionally narrow. It was not designed to turn Zyn Dwarf into a specialist model that answers every prompt with code.

### Why this approach?

Because a 350M model has a limited capacity budget.

A large fine-tuning dataset, aggressive rank, or excessive training could make the model more specialized while degrading general conversation quality.

The adaptation therefore uses a very small LoRA configuration rather than large-scale retraining.

---

## Identity

Zyn Dwarf's intended identity is:

```text
Name: Zyn Dwarf 1.0
Organization: Zyn's Labs
Role: Assistant

The current Ollama system instruction is intentionally minimal:

You are an assistant.

The model identity is primarily represented through the model’s fine-tuning and metadata instead of relying on a giant system prompt.

This keeps the runtime configuration lightweight.

---

Context Length

There are two values that should not be confused.

Upstream documented context

Liquid AI documents 32,768 tokens for LFM2.5-350M.
Source: https://huggingface.co/LiquidAI/LFM2.5-350M

GGUF/runtime metadata

The current GGUF contains a max_position_embeddings / context-related metadata value of 128,000.

Zyn Dwarf’s Ollama configuration

The Ollama package is intentionally configured with:

num_ctx = 32768

This is the conservative value used for the published model.

The larger metadata value should not be interpreted as a promise that Zyn Dwarf has been validated as a stable 128K-context model.

---

Quantization and Footprint

The published model uses:

Q4_K_M

This is a 4-bit GGUF quantization format commonly used for reducing model storage and runtime memory.

File sizes

Artifact	Approximate size
Zyn Dwarf Q4_K_M GGUF	~219 MiB
Ollama package	~229 MB
Parameter count	~354.5M

Why Q4_K_M?

The objective is a balance:

Smaller file
    ↓
Less storage
    ↓
Less memory pressure
    ↓
Faster loading
    ↓
Better suitability for local devices

The trade-off is that quantization can reduce numerical precision compared with higher-precision checkpoints.

---

Resource Profile

The project was tested on a small remote environment with approximately 3.8 GiB of RAM.

At one measured idle point after cleanup:

RAM total:       3.8 GiB
RAM used:        ~781 MiB
RAM available:   ~3.1 GiB
Swap:            0

These values describe the test environment, not a universal requirement.

Actual runtime memory depends on:

• Context length.
• Number of concurrent requests.
• Ollama runtime version.
• Operating system.
• CPU/GPU backend.
• KV cache configuration.
• Tool-call payload size.
• Number of loaded models.

Lightweight deployment strategy

The recommended configuration is:

One loaded model
+
Moderate context
+
Low concurrency
+
Q4_K_M

This keeps the model aligned with its main design goal: being small and inexpensive to run.

---

How the Model Was Adapted

The adaptation pipeline was approximately:

LFM2.5-350M base
        ↓
small coding-format dataset
        ↓
small LoRA
        ↓
merge
        ↓
GGUF conversion
        ↓
Q4_K_M quantization
        ↓
Ollama packaging

The behavioral dataset focused on examples involving:

• Python explanations.
• Python code generation.
• JavaScript code generation.
• TypeScript explanations.
• Intro → explanation → code → closing structure.

The LoRA configuration was intentionally tiny:

LoRA setting	Value
Rank	2
Alpha	4
Dropout	0.05
Target modules	q_proj, v_proj
Bias	none
Task	causal language modeling
Epochs	2
Learning rate	2e-5

The goal was behavioral reinforcement rather than broad knowledge replacement.

---

What Was Intentionally Not Changed

The project intentionally avoided:

• Increasing parameter count.
• Adding a large system prompt.
• Creating a vision encoder.
• Adding image capabilities that the architecture does not have.
• Adding an external retrieval system into the weights.
• Replacing the LFM2 architecture.
• Attempting to encode all 2026 news into the model.
• Heavy fine-tuning that could damage general abilities.

---

Comparison With Other Small Models

The table below compares Zyn Dwarf with several compact model families based on their published model specifications. This is a specification comparison, not a claim that Zyn Dwarf outperforms every model listed.

Compact-model comparison

Model	Parameters	Context	Architecture	License	Main positioning
Zyn Dwarf 1.0	~354M	32K configured	LFM2	LFM Open License + Zyn terms	Lightweight assistant, coding behavior, tools
Liquid AI LFM2.5-350M	~350M	32K documented	LFM2	LFM Open License	General-purpose edge/on-device model
SmolLM2-360M	360M	8K	Llama-style Transformer	Apache 2.0	Compact general text generation
SmolLM2-1.7B	1.7B	8K	Llama-style Transformer	Apache 2.0	Larger compact general model
Liquid AI LFM2-700M	~742M	32K	LFM2	LFM Open License	Larger LFM2 edge model
Liquid AI LFM2-1.2B	~1.17B	32K	LFM2	LFM Open License	Larger edge-oriented model
Liquid AI LFM2-2.6B	~2.57B	32K	LFM2	LFM Open License	Higher-capacity LFM2 model

Liquid AI publishes the LFM2 parameter counts and 32K context values for its compact LFM2 family. Hugging Face’s SmolLM2 documentation lists 135M, 360M, and 1.7B sizes and an 8K context for SmolLM2-360M.
Sources: - https://huggingface.co/LiquidAI/LFM2-350M - https://huggingface.co/LiquidAI/LFM2.5-350M - https://huggingface.co/HuggingFaceTB/SmolLM2-360M

---

Comparison With Its Upstream Model

Category	LFM2.5-350M	Zyn Dwarf 1.0
Parameters	~350M	~354.5M
Architecture	LFM2	LFM2
Base knowledge	Upstream	Upstream + small behavioral adaptation
Identity	Liquid AI	Zyn / Zyn’s Labs
Coding formatting	General	Reinforced
Tool-oriented packaging	Model-dependent	Explicit Ollama tools configuration
GGUF	Available	Q4_K_M package
Ollama	Available through compatible imports	Published directly
System prompt	Runtime-dependent	Minimal You are an assistant.
Main goal	General edge model	Small branded assistant
Upstream weights	Original	Derived/merged
Organization	Liquid AI	Zyn’s Labs

This is why Zyn Dwarf should be described as a derived model rather than pretending it was trained independently from scratch.

---

Capabilities Comparison

Capability	Zyn Dwarf	SmolLM2-360M	LFM2.5-350M
Text chat	Yes	Yes	Yes
Local inference	Yes	Yes	Yes
Small footprint	Yes	Yes	Yes
GGUF workflow	Yes	Widely available	Yes
Ollama	Yes	Available through compatible packaging	Available
Tools	Yes	Depends on template/runtime	Depends on runtime/template
Vision	No	No	No
Dedicated thinking mode	No	No dedicated mode	No separate thinking mode
Coding-focused adaptation	Yes	General	General
Brand-specific identity	Yes	No	No
2026 live knowledge	No	No	No

Ollama’s tool support is implemented through its API and a model’s compatible chat/template behavior rather than magically giving the model unrestricted access to outside systems.
Source: https://ollama.com/blog/tool-support

---

Performance Testing

Zyn Dwarf was tested in the remote environment during development.

A representative lightweight generation test was measured at approximately:

Metric	Measured value
Prompt processing	~259 tokens/s
Generation	~37–39 tokens/s
RAM during cleaned idle state	~781 MiB used
Available RAM after cleanup	~3.1 GiB
Swap	0

These are development-environment measurements, not standardized benchmark scores.

They should not be compared directly with another model’s benchmark unless:

• Hardware is identical.
• Runtime is identical.
• Quantization is identical.
• Context is identical.
• Prompt is identical.
• Generation settings are identical.
• Tokenizer behavior is identical.

---

Benchmark Policy

Zyn’s Labs should not publish invented benchmark numbers.

There is a large difference between:

"we tested this locally"

and:

"this model scores X on benchmark Y"

The second requires a reproducible evaluation protocol.

Future benchmark reports should include:

• Exact model hash.
• Exact quantization.
• Runtime version.
• Hardware.
• Context length.
• Temperature.
• Number of generations.
• Benchmark version.
• Evaluation prompt format.
• Whether tools were enabled.
• Whether results were generated locally or remotely.

---

Recommended Use Cases

Local assistant

Zyn Dwarf is suitable for small conversational assistants where a multi-billion-parameter model would be excessive.

Coding helper

The model is particularly interesting for:

• Short functions.
• Syntax explanations.
• Small debugging tasks.
• Code structure explanations.
• Python.
• JavaScript.
• TypeScript.
• Small code transformations.

Tool-oriented agents

Because Ollama detects tools, Zyn Dwarf can participate in lightweight agent pipelines.

Examples include:

User
 ↓
Zyn Dwarf
 ↓
tool call
 ↓
host application
 ↓
tool result
 ↓
Zyn Dwarf
 ↓
final response

Edge and low-resource deployment

The combination of:

• ~354M parameters.
• Q4_K_M.
• ~219 MiB GGUF.
• LFM2 hybrid architecture.

makes the model appropriate for experimenting with small local assistants and edge-oriented deployments.

---

Not Recommended For

Zyn Dwarf should not be presented as a replacement for large models.

It is not designed for:

• Very complex mathematical reasoning.
• Large codebase architecture.
• High-reliability software engineering without verification.
• Long autonomous coding sessions.
• Knowledge-intensive research without retrieval.
• High-stakes factual decisions.
• Massive-context document reasoning.
• Vision tasks.
• Audio tasks.
• Image generation.
• Live news without tools.

Liquid AI explicitly notes that small LFM models are best suited to focused use cases and that LFM2-350M-class models are not intended to be treated as large knowledge-intensive or programming-specialist models without appropriate fine-tuning.
Source: https://huggingface.co/LiquidAI/LFM2-350M

Zyn Dwarf’s coding adaptation improves its intended behavior, but it does not magically turn a 350M model into a modern large coding model.

---

Current-Information and 2026 News

Zyn Dwarf does not contain live knowledge of 2026 events.

A model cannot reliably know a news event simply because the word 2026 was placed into its prompt.

For current information, the recommended architecture is:

Zyn Dwarf
    |
    +---- web search tool
    |
    +---- news API
    |
    +---- application database
    |
    +---- current-data tool

The model can then reason over the returned information.

This is preferable to forcing a small model to hallucinate current events.

Liquid AI lists the upstream LFM2.5-350M knowledge cutoff as mid-2024.
Source: https://huggingface.co/LiquidAI/LFM2.5-350M

---

Ollama

Published model:

itsZyn/ZynDwarf-1.0

Model page:

https://ollama.com/itsZyn/ZynDwarf-1.0

Run

ollama run itsZyn/ZynDwarf-1.0

Pull

ollama pull itsZyn/ZynDwarf-1.0

API

Ollama exposes a local API that can be used from applications.

Example endpoint:

http://localhost:11434/api/chat

Tools

Ollama’s API accepts tools as part of the chat request.
Source: https://ollama.com/blog/tool-support

---

Ollama Configuration

Current relevant parameters:

Parameter	Value
num_ctx	32768
temperature	0.7
Tools	Enabled
Completion	Enabled

The package deliberately keeps the system message tiny:

You are an assistant.

This avoids spending context on a large identity prompt.

---

Using the Model

Basic CLI

ollama run itsZyn/ZynDwarf-1.0

Basic Python

from ollama import chat

response = chat(
    model="itsZyn/ZynDwarf-1.0",
    messages=[
        {
            "role": "user",
            "content": "Explain what a Python function is."
        }
    ],
)

print(response.message.content)

---

Tool Calling Example

The application supplies a tool.

from ollama import chat

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_weather",
            "description": "Get the current weather for a city.",
            "parameters": {
                "type": "object",
                "properties": {
                    "city": {
                        "type": "string",
                        "description": "City name"
                    }
                },
                "required": ["city"]
            }
        }
    }
]

response = chat(
    model="itsZyn/ZynDwarf-1.0",
    messages=[
        {
            "role": "user",
            "content": "What is the weather in Lima?"
        }
    ],
    tools=tools,
)

print(response.message.tool_calls)

The exact result depends on the prompt, generation settings, runtime, and tool schema.

---

Model Tags and Capabilities

Ollama’s detected capabilities for the current package are:

completion
tools

Why these are the correct tags

Tag/capability	Included?	Reason
completion	Yes	Standard text generation
tools	Yes	Compatible LFM2 tool template
vision	No	No visual encoder
embedding	No	Not an embedding model
reranking	No	Not a reranker
audio	No	Text-only
image generation	No	Text-only causal LM
thinking	No	No separate reasoning mode

The model should not claim capabilities that it cannot actually execute.

---

Limitations

Small model capacity

354M parameters is extremely small compared with modern multi-billion-parameter models.

This provides an enormous efficiency advantage but also limits:

• Complex reasoning.
• Long chains of reasoning.
• Deep code understanding.
• Difficult instruction following.
• Robustness against ambiguity.
• Factual recall.

Hallucinations

Zyn Dwarf can generate incorrect information.

It should not be treated as an authoritative source.

Programming limitations

The coding adaptation improves response structure but does not guarantee:

• Compilable code.
• Correct APIs.
• Correct library versions.
• Complete project architecture.
• Full debugging accuracy.
• Security correctness.

Generated code should be tested.

Tool-calling limitations

A tool-capable runtime does not guarantee perfect tool selection.

The model can:

• Select the wrong tool.
• Produce malformed arguments.
• Omit arguments.
• Misinterpret tool results.

Applications should validate tool arguments before execution.

Current information

Live information requires external tools.

---

Safety and Reliability

Zyn Dwarf is intended to be used as an assistant, not an autonomous authority.

Recommended deployment practices:

1. Validate tool arguments before execution.
2. Restrict tool permissions.
3. Use timeouts.
4. Log tool calls.
5. Validate generated code.
6. Keep secrets outside model prompts whenever possible.
7. Do not assume generated facts are correct.
8. Use retrieval for current information.
9. Use human review for high-impact decisions.

---

Licensing

Zyn Dwarf is derived from Liquid AI’s LFM2.5-350M model family.

The upstream license is the LFM Open License v1.0.

The complete upstream license text should remain distributed with the model and its redistribution package.

Zyn’s Labs-specific modifications are documented separately and do not replace the upstream license.

Licensing structure

Zyn Dwarf 1.0
│
├── Liquid AI upstream work
│      └── LFM Open License v1.0
│
└── Zyn's Labs original modifications
       └── Zyn's Labs additional terms

Important

Users must read the complete applicable license documents before redistributing or using the model commercially.

Official Liquid AI license:

https://www.liquid.ai/lfm-license

Official upstream model:

https://huggingface.co/LiquidAI/LFM2.5-350M

---

Attribution

Zyn Dwarf should be attributed to both the upstream model developer and the Zyn’s Labs project.

Suggested attribution:

Zyn Dwarf 1.0 is an adapted model derived from Liquid AI’s LFM2.5-350M family and developed/package-maintained by Zyn’s Labs.

This wording avoids implying that Zyn’s Labs created the underlying LFM2 architecture or original upstream training run.

---

Model Files

Recommended publication structure:

Zyn-Dwarf-1.0/
├── README.md
├── LICENSE-LIQUID-AI-LFM-OPEN-V1.txt
├── LICENSE-ZYN-LABS.txt
├── NOTICE
├── MODEL_CARD.json
├── SHA256SUMS
├── Modelfile
└── gguf/
    └── Zyn-Dwarf-1.0-code-format-Q4_K_M.gguf

GGUF

Primary local artifact:

Zyn-Dwarf-1.0-code-format-Q4_K_M.gguf

Approximate size:

219 MiB

---

Integrity

A checksum file should accompany each published model artifact.

Example:

sha256sum Zyn-Dwarf-1.0-code-format-Q4_K_M.gguf

The resulting SHA-256 value should be copied into:

SHA256SUMS

This allows users to verify that the file they downloaded is identical to the published artifact.

---

Reproducibility

A reproducible release should document:

• Upstream model identifier.
• Exact upstream revision.
• LoRA configuration.
• Training dataset revision.
• Training seed.
• Training arguments.
• Merge procedure.
• GGUF converter revision.
• Quantization command.
• Ollama version.
• Modelfile.
• SHA-256 checksum.

The goal is to make it possible for another developer to determine exactly how a release was produced.

---

Versioning

Recommended version format:

Zyn Dwarf 1.0

Future releases could use:

Zyn Dwarf 1.0.1
Zyn Dwarf 1.1
Zyn Dwarf 2.0

Suggested meaning

Version	Meaning
Patch	Packaging/configuration/fixes
Minor	Behavioral improvement without a fundamental redesign
Major	Significant new training, architecture, or capability change

---

FAQ

Is Zyn Dwarf trained from scratch?

No.

It is derived from Liquid AI’s LFM2.5-350M family.

How big is it?

The published Q4_K_M GGUF is approximately 219 MiB.

How many parameters does it have?

Approximately 354.5 million parameters.

Does it support tools?

Yes.

Ollama detects:

completion
tools

Does it support vision?

No.

Does it know 2026 news?

No. It requires an external current-information tool for live news.

Is it a coding model?

It is a general lightweight assistant with coding behavior reinforced through a small adaptation. It should not be presented as a large specialist coding model.

Can it run locally?

Yes. Local GGUF and Ollama packaging are primary deployment targets.

What is the model’s context?

Zyn Dwarf is configured for 32,768 tokens in Ollama.

Why does the GGUF contain 128K context metadata?

The underlying configuration contains 128K maximum-position metadata, but the upstream LFM2.5-350M model documentation lists 32,768 tokens as its context length. Zyn Dwarf therefore uses 32K as its conservative configured runtime context.

Does the system prompt define Zyn?

No large identity prompt is required.

The current runtime system message is simply:

You are an assistant.

Can it replace a 7B or 14B model?

Not in general.

Its purpose is efficiency, not maximum capability.

Why make such a small model?

Because many workloads do not need billions of parameters.

For simple local tasks, a compact model can be easier to deploy, cheaper to run, and easier to integrate.

---

Roadmap

Possible future improvements include:

Zyn Dwarf 1.1

• More robust coding-response formatting.
• Better tool-call argument consistency.
• More diverse lightweight programming examples.
• Additional regression testing.
• Better multilingual coding prompts.

Zyn Dwarf 1.2

Possible focus:

• Agent-oriented tasks.
• Better structured extraction.
• Better JSON behavior.
• Tool selection improvements.

Zyn Dwarf 2.x

Potentially:

• A larger Zyn model.
• A stronger coding-oriented variant.
• Specialized tool-agent checkpoints.
• Improved evaluation suite.
• Multiple quantization levels.

Any future training should preserve the central principle:

Make it better without making it unnecessarily bigger.

---

Credits

Upstream

Liquid AI

For the LFM2.5 architecture, upstream model, tokenizer, training, and associated research.

Zyn’s Labs

For:

• Zyn Dwarf model adaptation.
• Behavioral fine-tuning.
• Identity and packaging.
• Ollama integration.
• GGUF release workflow.
• Documentation.
• Testing and release engineering.

---

Sources

Official upstream model

Liquid AI LFM2.5-350M:

https://huggingface.co/LiquidAI/LFM2.5-350M

Liquid AI LFM2.5-350M Base:

https://huggingface.co/LiquidAI/LFM2.5-350M-Base

Liquid AI license:

https://www.liquid.ai/lfm-license

Ollama

Ollama tool calling:

https://ollama.com/blog/tool-support

Ollama GGUF/model support:

https://ollama.com/blog/improved-performance-and-model-support-with-gguf

Comparison model

SmolLM2-360M:

https://huggingface.co/HuggingFaceTB/SmolLM2-360M

SmolLM2-360M-Instruct:

https://huggingface.co/HuggingFaceTB/SmolLM2-360M-Instruct

---

Final Summary

Zyn Dwarf 1.0 is intentionally modest.

It is not a giant model compressed into a marketing sentence. It is a small model built around a simple engineering idea:

Small model
   +
Careful adaptation
   +
Good packaging
   +
Tool support
   +
Local deployment
   =
Useful lightweight assistant

The current release provides:

Zyn Dwarf 1.0
~354.5M parameters
Q4_K_M
~219 MiB GGUF
32K configured context
Completion
Tools
Coding-response adaptation
Ollama support
Liquid AI upstream attribution
Zyn's Labs identity

Small by design. Capable by nature.