Mira
Mira is a 14.8B-parameter conversational and reasoning language model developed by SmilyAI.
Mira is designed for programming, mathematics, reasoning, technical discussion, and general conversation, with a distinctive and expressive conversational style.
Current release: 09/19
Overview
Mira is a general-purpose language model fine-tuned for technical and conversational interaction.
The final fine-tuning stage focuses on:
- Conversational quality
- Reasoning
- Programming assistance
- Mathematical problem solving
- Technical explanations
- Code review and debugging
- Self-correction
- Instruction following
- Personality
Model Specifications
| Property | Value |
|---|---|
| Model | Mira |
| Organization | SmilyAI |
| Parameters | ~14.8B |
| Base model | Bc-AI/Nova-2-Large |
| Upstream foundation | Qwen3-14B |
| Fine-tuning method | LoRA |
| Layers | 40 |
| Hidden size | 5,120 |
| Context length | 40,960 tokens |
| Precision | bfloat16 |
| Primary language | English |
| Architecture | Transformer |
| Task | Text generation |
| Release | 09/19 |
Technical Lineage
Mira was developed through the following model pipeline:
Qwen3-14B
↓
DARE-TIES Merge (Code / Mathematics)
↓
Nova-2-Large
↓
LoRA Fine-tuning
↓
Mira
Nova-2-Large is Mira's immediate base model.
The final LoRA fine-tuning stage focuses on conversational behavior, reasoning, programming, personality, and technical interaction.
Capabilities
🧠 Reasoning
Mira is fine-tuned for multi-step reasoning and structured problem solving.
Typical use cases include:
- Breaking complex problems into smaller steps
- Comparing possible solutions
- Identifying incorrect assumptions
- Debugging technical problems
- Explaining solutions
- Reviewing and revising previous answers
When supported by the inference framework and prompting format, Mira may use <think> tags for reasoning.
Reasoning performance can vary depending on the task, prompt, inference framework, and generation settings.
💻 Programming
Mira is designed for programming and AI engineering tasks.
Use cases include:
- Python development
- Machine learning
- AI engineering
- Debugging
- Algorithm development
- Code review
- Code explanation
- Technical architecture
- Small software projects
Generated code should be reviewed and tested before deployment.
➗ Mathematics
Mira is intended to assist with mathematical problem solving and explanations.
Use cases include:
- Algebra
- Numerical problems
- Applied mathematics
- Algorithmic mathematics
- Mathematical reasoning
- Explaining mathematical concepts
Mathematical outputs may contain errors and should be independently verified when accuracy is important.
Conversational Style
Mira has been fine-tuned with a distinctive conversational style.
Its intended characteristics include:
- Friendly
- Curious
- Energetic
- Technically enthusiastic
- Slightly playful
- Direct
- Honest about uncertainty
The personality is intended to complement Mira's technical capabilities without interfering with task accuracy.
🔥 Roast Mode
Mira supports an optional playful Roast Mode for code review.
The design principle is:
Roast the code, not the developer.
Roast Mode is intended to make code review more entertaining while remaining constructive and focused on technical issues.
Intended Use
Mira is intended for:
- Programming assistance
- AI/ML experimentation
- Code debugging
- Mathematical problem solving
- Technical research
- Engineering discussions
- Robotics brainstorming
- Conversational AI experimentation
- Personal AI development
Limitations
Mira is a generative language model and can produce incorrect or misleading information.
Potential limitations include:
- Hallucinated information
- Incorrect or incomplete code
- Mathematical errors
- Incorrect assumptions
- Misinterpretation of ambiguous instructions
- Outdated information
- Overconfident responses
- Inconsistent reasoning on difficult problems
Reasoning behavior does not guarantee correctness.
Users should independently verify important technical, mathematical, or factual outputs.
Training
Mira's final fine-tuning stage uses LoRA (Low-Rank Adaptation) applied to Nova-2-Large.
The fine-tuning focuses on:
- Conversational behavior
- Reasoning
- Programming
- Technical interaction
- Personality
- Self-correction
- Instruction following
The exact training dataset composition, hyperparameters, LoRA configuration, and training mixture are proprietary to SmilyAI.
Architecture
Mira contains approximately 14.8 billion parameters.
Key architectural characteristics:
- 40 transformer layers
- 5,120 hidden dimensions
- 40,960-token context window
- bfloat16 computation
Recommended Generation Settings
The following configuration provides a reasonable starting point:
outputs = model.generate(
**inputs,
max_new_tokens=512,
temperature=0.7,
)
Recommended values may vary depending on the application.
Lower temperatures generally produce more deterministic responses, while higher temperatures allow greater output variation.
Usage
from transformers import AutoTokenizer, AutoModelForCausalLM
import torch
model_name = "Bc-AI/Mira"
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForCausalLM.from_pretrained(
model_name,
dtype=torch.bfloat16,
device_map="auto"
)
messages = [
{
"role": "user",
"content": "Debug this Python function for me."
}
]
text = tokenizer.apply_chat_template(
messages,
tokenize=False,
add_generation_prompt=True
)
inputs = tokenizer(
text,
return_tensors="pt"
).to(model.device)
outputs = model.generate(
**inputs,
max_new_tokens=512,
temperature=0.7
)
response = tokenizer.decode(
outputs[0][inputs.input_ids.shape[1]:],
skip_special_tokens=True
)
print(response)
Prompting
Mira generally performs best when instructions provide sufficient context.
For programming tasks, consider including:
- The relevant code
- The expected behavior
- The observed behavior or error
- Any relevant constraints
Example
I have a Python function that should calculate the
average of a list, but it sometimes returns the wrong value.
Here is the code:
[paste code]
Find the bug, explain why it happens, and provide a fix.
Safety and Responsible Use
Mira is a general-purpose language model and may generate inaccurate, unsafe, or misleading content.
It should not be treated as:
- Professional medical advice
- Professional legal advice
- Professional financial advice
- An autonomous decision-maker
- A guaranteed source of factual information
- A security-critical coding authority
For safety-critical or high-impact applications, additional safeguards, testing, and human oversight are recommended.
Privacy
Deployers are responsible for ensuring that applications using Mira handle user-provided information appropriately.
This includes inference logs, application databases, external tools, and other systems connected to the model.
Users should avoid providing sensitive personal information unless the deployment environment provides appropriate protections.
License
Proprietary — Private Use Only
Mira is not released under a general open-source license.
Permission to use, copy, modify, redistribute, host, or commercially deploy Mira is determined by the terms specified by SmilyAI.
Mira's upstream model components may be subject to separate licenses and usage requirements. Users are responsible for complying with applicable upstream terms.
Attribution
Mira is built using Bc-AI/Nova-2-Large as its immediate base model.
Nova-2-Large is derived from the Qwen3-14B model family and incorporates a DARE-TIES merge.
Users should review the applicable upstream licenses and attribution requirements before redistribution or deployment.
Credits
Developed by SmilyAI
Mira is an independent SmilyAI model focused on conversational interaction, reasoning, programming, mathematics, and technical assistance.
Mira — SmilyAI
AI for everyone.
09/19 Release