Mira-1-large

Mira

MIRA IS THE LAST MODEL IN THE NOVA SERIES

Mira is a specialized conversational and reasoning model developed by SmilyAI.

Mira is built through a multi-stage model lineage rather than being trained directly from the original Qwen3 checkpoint:

Qwen3-14B → DARE-TIES code/math merge → Nova-2-Large → LoRA fine-tuning → Mira

Mira’s goal is to combine strong coding and mathematical capabilities with a distinctive, friendly personality and useful conversational behavior.

Model Lineage

1. Qwen3-14B

The underlying architectural foundation comes from Qwen3-14B.

Qwen3 provides the foundation for Mira’s transformer architecture and general language capabilities.

1. Nova-2-Large

Bc-AI/Nova-2-Large was developed by SmilyAI from the Qwen3-14B foundation.

Nova-2-Large incorporates a DARE-TIES merge focused on improving code and mathematics capabilities.

This means Mira is not a direct Qwen3-14B LoRA model. Its immediate base model is Nova-2-Large.

1. Mira

Mira is created by applying LoRA fine-tuning to Nova-2-Large.

The fine-tuning focuses primarily on:

• Personality
• Conversational behavior
• Reasoning behavior
• Code-related interaction
• Self-correction
• Helpful technical responses

Model Details

Property Value Model Mira Organization SmilyAI Immediate base model Bc-AI/Nova-2-Large Upstream foundation Qwen3-14B Nova merge DARE-TIES Fine-tuning LoRA Parameters ~14.8B Layers 40 Hidden size 5120 Context length 40,960 tokens Precision bfloat16 Primary language English Architecture Transformer Intended use Conversational AI, coding, reasoning

Capabilities

🧠 Reasoning

Mira is fine-tuned to perform structured reasoning and problem solving.

Its intended reasoning behaviors include:

• Breaking complex problems into smaller steps
• Checking intermediate conclusions
• Revisiting incorrect assumptions
• Debugging code methodically
• Explaining technical concepts
• Verifying solutions where appropriate

When configured with a compatible prompting format, Mira may produce reasoning traces using <think> tags.

Reasoning behavior can vary depending on the inference framework, prompt format, sampling parameters, and deployment configuration.

💻 Coding

Mira inherits much of its coding capability from the Nova-2-Large lineage and its underlying code-focused merge.

It is intended for:

• Python
• Machine learning
• AI engineering
• Debugging
• Algorithmic reasoning
• Code explanation
• Technical brainstorming
• Small software projects

Mira is designed to review and improve code rather than simply generate code without explanation.

💬 Conversational Personality

Mira was specifically fine-tuned to have a recognizable conversational style.

The intended personality is:

• Curious
• Friendly
• Energetic
• Slightly playful
• Technically enthusiastic
• Honest about limitations
• Interested in AI and engineering

Mira is designed to feel more like an AI engineering companion than a purely formal coding assistant.

🔥 Roast Mode

Mira can optionally use a playful “roast mode” during code review.

The principle is:

Roast the code, never the coder.

For example, Mira may humorously point out questionable code while still explaining what is wrong and providing a practical fix.

Roast mode should remain constructive and should not become harassment or personal attacks.

Intended Use

Mira is primarily intended for:

• AI/ML experimentation
• Programming assistance
• Code debugging
• Mathematics
• Technical discussion
• Conversational experimentation
• Robotics and engineering brainstorming
• Personal AI research and development

Not Intended For

Mira should not be treated as:

• A replacement for professional medical, legal, or financial advice
• An autonomous decision-maker
• A guaranteed source of factual information
• A security-critical coding authority
• A system whose generated code should automatically be executed without review

Generated outputs should be reviewed by a human before being used in important systems.

Limitations

Despite its capabilities, Mira can still:

• Hallucinate facts
• Generate incorrect code
• Make mathematical mistakes
• Misinterpret ambiguous prompts
• Produce plausible but incorrect explanations
• Fail to recognize when information is outdated
• Overestimate its own confidence

Reasoning behavior does not guarantee correctness.

For important tasks, users should independently verify the model’s output.

Training

Mira uses LoRA (Low-Rank Adaptation) for its final fine-tuning stage.

Rather than updating all model parameters, LoRA introduces trainable low-rank adapter weights into the underlying model.

The fine-tuning datasets are focused on:

• Personality
• Reasoning
• Conversational behavior
• Technical interaction
• Code-oriented behavior

The exact training datasets, training mixture, hyperparameters, and adapter configuration are proprietary to SmilyAI.

Model Architecture

Mira contains approximately 14.8 billion parameters.

Key architectural specifications include:

• 40 transformer layers
• 5120-dimensional hidden representation
• 40,960-token context window
• bfloat16 inference/training precision

The model architecture ultimately derives from the Qwen3-14B lineage through Nova-2-Large.

Model Lineage Diagram

Qwen3-14B │ ▼ DARE-TIES Merge (Code / Mathematics) │ ▼ Nova-2-Large (Bc-AI/Nova-2-Large) │ │ LoRA Fine-tuning │ ├── Personality ├── Reasoning ├── Conversation └── Technical behavior │ ▼ Mira (Bc-AI/Mira)

Recommended Generation Settings

These settings are a reasonable starting point and may be adjusted depending on the application.

outputs = model.generate( **inputs, max_new_tokens=512, temperature=0.7, )

For deterministic or highly consistent responses, a lower temperature may be preferable.

For more creative conversational behavior, a somewhat higher temperature can be used.

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 works best when given clear instructions and sufficient context.

For coding tasks, providing:

1. The relevant code
2. The expected behavior
3. The observed behavior or error
4. Any constraints

will generally produce better results.

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

Mira is a general-purpose language model and may generate unsafe, incorrect, or misleading information.

Users are responsible for evaluating generated outputs before acting on them.

The model should not be deployed in safety-critical or high-impact applications without appropriate additional safeguards, testing, and human oversight.

Privacy

Mira is intended for private use.

Users deploying Mira should ensure that their inference environment and any connected applications handle user-provided data appropriately.

Do not provide sensitive personal information to the model unless the deployment environment has 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 lineage may contain components subject to separate licenses or usage restrictions. Users are responsible for complying with the applicable upstream terms.

Attribution

Mira’s model lineage includes technology derived from the Qwen3-14B model family.

The immediate base model for Mira is:

Bc-AI/Nova-2-Large

Nova-2-Large itself is derived from Qwen3-14B and incorporates a DARE-TIES merge focused on code and mathematics.

Credits

Developed by SmilyAI.

Mira is part of the broader Nova model ecosystem and represents a specialized branch focused on conversational personality, reasoning, coding, and technical assistance.

⸻

Mira — SmilyAI

AI for everyone.