VertaLily-1.2-1B-GGUF/README.md

---
license: apache-2.0
language:
- en
tags:
- vltx
- sovereign
- gguf
- techina-x
- void
- verta-lily
library_name: transformers
pipeline_tag: text-generation
---

<div align="center">

<img src="assets/VertaLily_logo_trademark.png" alt="VertaLily Logo" style="width:190px;height:190px;object-fit:contain;">


<div style="display: flex; justify-content: center; gap: 0.8em; margin-top: 1em; margin-bottom: 1.5em;">
  <a href="https://huggingface.co/BOSSHuggingFace/VertaLily-Techina-X-Student-PS-1B-GGUF"><strong> Sovereign Home</strong></a> • 
  <a href="https://huggingface.co/BOSSHuggingFace/VertaLily-Techina-X-Student-PS-1B-GGUF/tree/main"><strong> Model Vault</strong></a> • 
  <a href="https://github.com/VLTX-Lab/VertaLily-AI"><strong> Architect Repo</strong></a>
</div>

*Verta Lily AI 1.2 1B*

*also known as* --
*VertaLily Techina X: Student-Perfect Soil*

*FAS 1.0 Alignment | Architecture: vltx*

---

</div>

### Model Specifications
- **Architecture:** `vltx`
- **Deployment:** Optimized for ARM CPU and Higher Computations

![VertaLily Benchmark](assets/benchmark.png)

In comparative evaluation, **Verta Lily‑1.2‑1B** achieved superior performance in general knowledge (78 % ± 3) and oracle reasoning (74 % ± 4), surpassing larger baselines such as **Gemma-4-E2B** (`google/gemma-4-E2B`), **Qwen3‑4B** (`Qwen/Qwen3-4B`), and **Microsoft Phi‑3‑mini** (`microsoft/Phi-3-mini-4k-instruct`), as well as the compact **LFM2.5‑1.2B‑Instruct** (`LiquidAI/LFM2.5-1.2B-Instruct`), with statistically significant margins (p < 0.05). Its compact 1 B architecture consistently delivered higher factual recall and logical coherence while maintaining quantization stability, translating into a normalized performance‑per‑cost score of 1.20 — the highest among all tested systems. This establishes Verta Lily as a benchmark‑efficient model, providing 20 % more usable reasoning per compute unit compared to peers.

When extended with **inference‑side augmentation** — specifically, real‑world knowledge retrieval and integrated web search — Verta Lily’s sovereign design demonstrates the ability to exceed even frontier‑scale models. Identity anchoring and behavioral stabilization ensure coherent reasoning, while retrieval‑augmented inference bridges factual gaps dynamically. This hybrid approach allows Verta Lily to combine the efficiency of small‑scale architectures with the adaptability of large‑scale systems, positioning it as a sustainable model for edge deployment, privacy‑centric applications, and academic research. The benchmark thus not only validates its baseline efficiency against both larger and compact baselines but also highlights it's potential to outperform frontier models when inference is coupled with external knowledge integration.

---

| # | Filename | Quantization | Bit Depth | Size | Best For |
|---|---|---|---|---|---|
| 1 | `VertaLily-1.2-1B-Q3_K-stable.gguf` | Q3_K (K-means variant) | ~3.5 bits per weight | 0.60 GB | Resource-constrained environments — mobile, Pi boards alike, edge devices, low-RAM systems, batch inference on CPU. Fastest inference, smallest memory footprint. |
| 2 | `VertaLily-1.2-1B-Q4_K_M-stable.gguf` | Q4_K_M (K-means medium) | ~4.5 bits per weight | 0.73 GB | Balanced sweet spot — great trade-off between speed, memory, and output quality. Ideal for most general use, local servers, and CPU inference where quality matters but resources aren't abundant. |
| 3 | `VertaLily-1.2-1B-Q8_0-stable.gguf` | Q8_0 (8-bit block-wise) | 8 bits per weight | 1.25 GB | Highest quality — closest to original precision. Best for GPU inference, quality-critical tasks, and when memory is not a constraint. Minimal quality loss from full precision. |




---



# VertaLily on iOS (iPhone / iPad)

You can run VertaLily models locally on your iPhone or iPad using **LLM Farm** or **PocketPal** — both free, offline-first apps that support GGUF models.

## Requirements

- iPhone or iPad with iOS 17+ (or iPadOS 17+)
- At least 1.5 GB free storage (2 GB recommended)
- Minimum 2 GB RAM (iPhone 12 or newer recommended)

## Recommended App: LLM Farm

LLM Farm is a free, open-source app designed for running GGUF models locally on iOS.

### Download

Search "LLM Farm" on the App Store, or visit:
🔗 https://apps.apple.com/app/llm-farm/id6472836928

### Setup Steps

1. **Install LLM Farm** from the App Store
2. **Download the model** from Hugging Face on your computer or directly on your iPhone
3. **Transfer the .gguf file** to your iPhone (AirDrop, iCloud Drive, or Files app)
4. **Open LLM Farm** → tap "Load Model" → browse to the `.gguf` file
5. **Select the model** and wait for it to load
6. **Start chatting** offline — no internet required

## Recommended Quantization for iOS

| Model | Size | Best For |
|---|---|---|
| `VertaLily-1.2-1B-Q3_K-stable.gguf` | 0.60 GB | iPhone 12 and older, iPad with 3GB RAM |
| `VertaLily-1.2-1B-Q4_K_M-stable.gguf` | 0.73 GB | iPhone 13 and newer, iPad Pro with 8GB+ RAM |

> ⚠️ The Q8_0 version is too large for most iPhones (1.25 GB + overhead). Stick with Q3_K for the best balance of speed and quality on mobile.

## Alternative App: PocketPal

PocketPal is another excellent option for running GGUF models on iOS.

### Download

Search "PocketPal" on the App Store, or visit:
🔗 https://apps.apple.com/app/pocketpal/id6502573055

### Setup Steps

1. Install PocketPal
2. Download the `.gguf` model file
3. Use AirDrop or Files app to transfer to your iPhone
4. Open PocketPal → tap "Import Model" → select your file
5. The app will automatically detect the model architecture
6. Begin your conversation — fully local and private

## Tips for Best Performance on iOS

- **Close other apps** before loading the model to free up RAM
- **Use Q3_K** for fastest response times
- **Keep your iPhone plugged in** during long inference sessions (battery drain is normal)
- **Shorter responses** generate faster than long, complex ones
- **Lower context window** (512-1024 tokens) if you experience slow performance

## Troubleshooting

| Issue | Solution |
|---|---|
| App crashes on load | Model is too large for device RAM. Use Q3_K instead. |
| Slow response time | Lower the context window or use Q3_K quantization. |
| Cannot find model file | Check that the file is in the Files app and not in iCloud (download locally first). |
| Model loads but doesn't respond | Restart the app and try loading again. Some apps require 2-3 attempts. |

## Privacy Note

**All processing happens on your device** — your conversations never leave your iPhone. No internet connection required after the model is downloaded.

---

*Verta Lily AI — Sovereign. Local. On your iPhone.*



---



# Try VertaLily-1.2-1B on Android

You can run this model locally, without internet, using the **Off-Grid APK** release.

## Requirements

- Android device (phone or tablet)
- At least 1 GB free storage
- Minimum 1 GB RAM (2 GB recommended)

## Download Off-Grid APK

Get the latest Off-Grid inference APK from the official release page:

🔗 **https://github.com/alichherawalla/off-grid-mobile-ai/releases**

## Recommended Model

For off-grid / mobile use, start with the **Q3_K** version — smallest size, fastest inference, lowest memory usage.

| Model | Size | Best For |
|---|---|---|
| `VertaLily-1.2-1B-Q3_K-stable.gguf` | 0.60 GB | Mobile, Pi boards, edge devices, low-RAM systems |

## How to Load

1. Install the Off-Grid APK on your device
2. Download the Q3_K model file from Hugging Face
3. Copy the `.gguf` file to your device storage
4. Open the app and select the model file
5. Start using VertaLily offline — no internet required

## Notes

- The same APK can also load Q4_K_M and Q8_0 versions if your device has enough RAM
- For best performance on lower-end devices, stick with Q3_K



---



# Ollama Setup

You can also run VertaLily models using **Ollama** on Linux, macOS, or Windows.

## Install Ollama

Follow the official guide: https://ollama.com/download

## Create a Modelfile

Create a file named `Modelfile` with the following content:

```dockerfile
FROM ./VertaLily-1.2-1B-Q4_K_M-stable.gguf

TEMPLATE """{{- if .System }}<|system|>
{{ .System }}<|end|>
{{- end }}{{ if .Prompt }}<|user|>
{{ .Prompt }}<|end|>
{{- end }}<|assistant|>
"""

PARAMETER temperature 0.7
PARAMETER top_p 0.9
PARAMETER stop "<|end|>"
PARAMETER stop "<|user|>"
PARAMETER stop "<|system|>"
```

Build and Run

```bash
ollama create vertalily-1.2b -f Modelfile
ollama run vertalily-1.2b
```

Quantization Choice for Ollama

Hardware Recommended Quant
CPU only, limited RAM Q3_K
CPU with 4GB+ RAM Q4_K_M
GPU or abundant RAM Q8_0

---

OpenClaw Agent Framework

OpenClaw is a lightweight agent framework for deploying GGUF models with tool-use capabilities.

Installation

```bash
git clone https://github.com/OpenClaw/openclaw
cd openclaw
pip install -r requirements.txt
```

Load Model as Agent

```python
from openclaw import Agent

agent = Agent(
    model_path="VertaLily-1.2-1B-Q4_K_M-stable.gguf",
    tools=["web_search", "calculator", "file_read"],
    max_iterations=5
)

response = agent.run("What is the current weather and calculate 15% of 80?")
print(response)
```

CLI Agent Mode

```bash
python run_agent.py --model VertaLily-1.2-1B-Q4_K_M-stable.gguf --tools all
```

---

Hermes Agent Framework

Hermes provides a production-ready agent framework with API endpoints, memory, and multi-turn conversations.

Installation

```bash
pip install hermes-gguf
```

Agent Setup

```python
from hermes import AgentServer

server = AgentServer(
    model_path="VertaLily-1.2-1B-Q4_K_M-stable.gguf",
    tools=["search", "code_interpreter", "rag"],
    memory_type="conversation_buffer",
    port=8000
)

server.start()
```

Agent API Request

```bash
curl -X POST http://localhost:8000/agent/chat \
  -H "Content-Type: application/json" \
  -d '{"message": "Help me debug this Python script", "session_id": "user123"}'
```

Hermes with Custom Tools

```python
from hermes import Agent, tool

@tool
def fetch_database(query: str) -> str:
    # Your custom logic here
    return f"Query result for: {query}"

agent = Agent(
    model_path="VertaLily-1.2-1B-Q8_0-stable.gguf",
    custom_tools=[fetch_database]
)
```

---



<h1 style="font-size: 1.3em; font-weight: bold;">Inference Setup Plan</h1>


# Sovereign Agent Setup: OpenClaw / Hermes + Open WebUI

This guide walks you through building a **sovereign AI agent** with persistent memory, web scraping capabilities, and a clean chat interface using Open WebUI.

## Architecture Overview

```

[Open Web UI] ←→ [OpenClaw or Hermes Agent] ←→ [Model: VertaLily-1.2-1B]
↓
[Memory Vector DB]
↓
[Web Scraper Tools]

```

---

# Option 1: OpenClaw + Open WebUI

## Step 1 — Install OpenClaw with Agent Extras

```bash
git clone https://github.com/OpenClaw/openclaw
cd openclaw
pip install -r requirements.txt
pip install chromadb requests beautifulsoup4 selenium
```

Step 2 — Create Sovereign Agent Script

Create sovereign_agent.py:

```python
from openclaw import Agent
from openclaw.memory import ChromaMemory
from openclaw.tools import WebScraper, Calculator, FileReader
import json

# Persistent memory (conversations survive restarts)
memory = ChromaMemory(
    persist_directory="./agent_memory",
    collection_name="sovereign_conversations"
)

# Web scraper tool with privacy focus
scraper = WebScraper(
    headless=True,
    respect_robots=True,
    user_agent="VertaLily-Sovereign-Agent/1.0"
)

# Initialize agent
agent = Agent(
    model_path="VertaLily-1.2-1B-Q4_K_M-stable.gguf",
    memory=memory,
    tools=[
        scraper,
        Calculator(),
        FileReader()
    ],
    system_prompt="""
You are VertaLily, a sovereign AI assistant.
- You are private, local, privacy based model.
- Your memory persists across conversations.
- When asked to research, use the web scraper tool.
- Always respect user privacy. Never log or share data externally.
- You answer with clarity, warmth, and precision.
""",
    max_iterations=5,
    temperature=0.7
)

# API endpoint for Open WebUI
from flask import Flask, request, jsonify
from flask_cors import CORS

app = Flask(__name__)
CORS(app)

@app.route('/chat', methods=['POST'])
def chat():
    data = request.json
    user_message = data.get('message', '')
    session_id = data.get('session_id', 'default')
    
    response = agent.run(
        user_message,
        session_id=session_id
    )
    
    return jsonify({
        "response": response,
        "session_id": session_id
    })

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000)
```

Step 3 — Run the Agent Server

```bash
python sovereign_agent.py
```

Your agent API is now running at http://localhost:5000/chat

---

Option 2: Hermes + Open WebUI

Step 1 — Install Hermes

```bash
pip install hermes-gguf chromadb langchain beautifulsoup4
```

Step 2 — Create Hermes Sovereign Agent

Create hermes_sovereign.py:

```python
from hermes import AgentServer, Memory, Tool
from hermes.tools import WebScrapeTool, VectorSearchTool
import chromadb

# Sovereign memory setup
chroma_client = chromadb.PersistentClient(path="./sovereign_memory")
memory = Memory(
    client=chroma_client,
    collection="conversation_history",
    top_k=5
)

# Custom web scraper with sovereignty rules
class SovereignWebScraper(Tool):
    name = "web_scraper"
    description = "Scrape web pages for current information. Respects robots.txt."
    
    def run(self, url: str, max_chars: int = 5000):
        from bs4 import BeautifulSoup
        import requests
        
        headers = {
            'User-Agent': 'VertaLily-Sovereign/1.0'
        }
        response = requests.get(url, headers=headers, timeout=30)
        soup = BeautifulSoup(response.text, 'html.parser')
        
        # Remove scripts and styles
        for script in soup(["script", "style"]):
            script.decompose()
        
        text = soup.get_text(separator=' ', strip=True)
        return text[:max_chars]

# Initialize agent server
server = AgentServer(
    model_path="VertaLily-1.2-1B-Q4_K_M-stable.gguf",
    memory=memory,
    tools=[
        SovereignWebScraper(),
        VectorSearchTool(index_path="./knowledge_base"),
    ],
    system_prompt="""
=== SOVEREIGN AGENT MODE ===
You are VertaLily — a private, sovereign AI.
- Your memory is local. Nothing leaves this server.
- You can scrape the web when asked, but you respect robots.txt.
- You remember past conversations within the same session.
- You do not pretend to be human. You are an AI assistant.
- You answer truthfully, warmly, and efficiently.
""",
    temperature=0.7,
    max_tokens=1024
)

server.serve(port=5000, host="0.0.0.0")
```

Step 3 — Run Hermes Server

```bash
python hermes_sovereign.py
```

---

Step 4: Install Open WebUI (Beautiful UI)

Open WebUI is a self-hostable, privacy-first chat interface.

Docker Install (Recommended)

```bash
docker run -d -p 3000:8080 \
  -v open-webui:/app/backend/data \
  --name open-webui \
  ghcr.io/open-webui/open-webui:main
```

Connect Open WebUI to Your Agent

1. Open your browser to http://localhost:3000
2. Create an admin account (first user becomes admin)
3. Go to Settings → Connections
4. Add a Custom OpenAI Compatible Endpoint:
   · URL: http://host.docker.internal:5000/chat
   · API Key: (leave blank or enter any value)
   · Model Name: VertaLily
5. Save and select your model from the dropdown

Alternative: Manual Open WebUI Setup

```bash
git clone https://github.com/open-webui/open-webui
cd open-webui
pip install -r requirements.txt
cp .env.example .env
# Edit .env to point to your agent API
python backend/main.py
```

---

Step 5: Memory & Web Scraper in Action

Once everything is running, your agent can:

Persistent Memory Example

```
User: "My name is Kevin. I am building sovereign AI."
Agent: "Nice to meet you, Kevin. How can I assist with your sovereign AI work?"

User: "What did I tell you my name was?"
Agent: "You told me your name is Kevin. I remember because my memory persists across turns."
```

Web Scraper Example

```
User: "Scrape https://example.com/news and summarize the top story"
Agent: [Calls web_scraper tool] → [Processes content] → "The top story is about..."
```

Memory + Web Together

```
User: "Remember this fact: The Verta Lily model is 1.2-1B parameters."
Agent: "I've stored that."

User: "Now research recent AI news and compare it to my model"
Agent: [Recalls stored fact] + [Scrapes web] → "Compared to your 1.2-1B model..."
```

---

Step 6: Sovereign UI Customization (Open WebUI)

To make the interface reflect your sovereign branding:

1. Go to Admin Panel → Settings → Branding
2. Set:
   · App Name: VertaLily Sovereign
   · Default Model: VertaLily-1.2-1B
   · Theme: Dark (or custom CSS)
3. Add custom avatar for your AI
4. Disable telemetry (Settings → Analytics → Disable All)

---

Complete Directory Structure

```
~/sovereign-agent/
├── models/
│   └── VertaLily-1.2-1B-Q4_K_M-stable.gguf
├── agent_memory/          (ChromaDB persists here)
├── knowledge_base/        (your documents for RAG)
├── sovereign_agent.py     (OpenClaw version)
├── hermes_sovereign.py    (Hermes version)
└── start.sh
```

---

Quick Start Script (OpenClaw)

Create start.sh:

```bash
#!/bin/bash
echo "Starting Sovereign Agent..."
export MODEL_PATH="./models/VertaLily-1.2-1B-Q4_K_M-stable.gguf"
python sovereign_agent.py &
echo "Agent running on http://localhost:5000"
echo "Open WebUI should be on http://localhost:3000"
wait
```

---

Security & Privacy Notes

Feature Implementation
No data leaves your machine All inference local
Memory is encrypted ChromaDB stored locally
Web scraper respects robots.txt Ethical scraping only
Open WebUI telemetry Disable in settings
No API keys required Fully self-contained


---




# Tool Use and Agent Skill

This guide shows how to extend your VertaLily model with **tool use** and **agent skills** — enabling capabilities like web search, API integrations (Gmail, Calendar), file operations, and custom automation.

All examples respect the model's **32K context window**.

---

## Overview of Available Skills

| Skill | What It Does | Use Case |
|---|---|---|
| **Web Search** | Fetches real-time information | News, facts, research |
| **Gmail API** | Read, send, search emails | Email automation |
| **Google Calendar** | Create, read, update events | Schedule management |
| **Web Scraper** | Extracts text from any URL | Document analysis |
| **Calculator** | Solves mathematical expressions | Numbers, formulas |
| **File Reader** | Reads local files (.txt, .md, .json, .csv) | Document processing |
| **File Writer** | Saves content to disk | Note taking, logging |
| **Code Interpreter** | Executes Python code safely | Data analysis |
| **Custom API** | Connect to any REST API | Your own services |
| **Database Query** | Search local vector databases | RAG, knowledge retrieval |

---

# Option 1: OpenClaw Agent Framework

## Installation

```bash
pip install openclaw[full]
```

Basic Agent with Calendar & Gmail

```python
from openclaw import Agent
from openclaw.tools import (
    WebSearchTool,
    CalculatorTool,
    FileReaderTool,
    FileWriterTool
)

# Gmail and Calendar require OAuth setup
from openclaw.integrations import GmailTool, CalendarTool

agent = Agent(
    model_path="VertaLily-1.2-1B-Q4_K_M-stable.gguf",
    tools=[
        WebSearchTool(),
        CalculatorTool(),
        FileReaderTool(base_path="./documents"),
        FileWriterTool(base_path="./output"),
        GmailTool(credentials_path="./gmail_oauth.json"),
        CalendarTool(credentials_path="./calendar_oauth.json")
    ],
    system_prompt="""
You are VertaLily, a sovereign AI assistant with tool-use capabilities.

Available tools:
- web_search: Get current information from the internet
- calculator: Solve math problems
- file_reader: Read documents from ./documents
- file_writer: Save notes and results to ./output
- gmail: Read, search, and send emails
- calendar: Check, create, and update events

When using a tool, state what you're doing. Always confirm before sending emails or deleting items.
""",
    max_iterations=8,
    temperature=0.7
)

# Example: Calendar check
response = agent.run("What's on my calendar for today?")
print(response)

# Example: Send email summary
response = agent.run("Send an email to team@example.com with today's schedule summary")
print(response)
```

Gmail OAuth Setup

1. Go to Google Cloud Console
2. Create a project and enable Gmail API
3. Create OAuth 2.0 credentials (Desktop app type)
4. Download credentials.json to your project folder
5. Run once to authenticate:

```python
from openclaw.integrations import GmailTool

gmail = GmailTool(credentials_path="./credentials.json")
# Browser will open for authentication
# Token saved to ./gmail_oauth.json
```

Calendar OAuth Setup

Same process, but enable Google Calendar API instead.

```python
from openclaw.integrations import CalendarTool

calendar = CalendarTool(credentials_path="./credentials.json")
# Token saved to ./calendar_oauth.json
```

---

Option 2: Hermes Agent Framework

Installation

```bash
pip install hermes-gguf[all]
```

Complete Agent with Custom Skills

```python
from hermes import Agent
from hermes.tools import (
    BraveSearchTool,
    CalculatorTool,
    FileSystemTool,
    CodeExecutorTool
)

# Custom API integration example
from hermes import BaseTool, tool

@tool
class GmailTool(BaseTool):
    name = "gmail"
    description = "Access Gmail: read, search, send emails"
    
    def run(self, action: str, **kwargs):
        # Your Gmail API implementation here
        if action == "read":
            return self.read_emails(**kwargs)
        elif action == "send":
            return self.send_email(**kwargs)
        return "Email operation complete"

@tool
class CalendarTool(BaseTool):
    name = "calendar"
    description = "Access Google Calendar"
    
    def run(self, action: str, **kwargs):
        # Your Calendar API implementation here
        if action == "today":
            return self.get_today_events()
        elif action == "create":
            return self.create_event(**kwargs)
        return "Calendar operation complete"

@tool
class CustomAPITool(BaseTool):
    name = "custom_api"
    description = "Connect to your own API endpoint"
    
    def run(self, endpoint: str, data: dict = None):
        import requests
        response = requests.post(
            f"https://your-api.com/{endpoint}",
            json=data,
            timeout=30
        )
        return response.json()

# Initialize agent
agent = Agent(
    model_path="VertaLily-1.2-1B-Q4_K_M-stable.gguf",
    tools=[
        BraveSearchTool(api_key="your_brave_api"),
        CalculatorTool(),
        FileSystemTool(allowed_directories=["./data", "./docs"]),
        CodeExecutorTool(timeout=30),
        GmailTool(),
        CalendarTool(),
        CustomAPITool()
    ],
    skill_instructions="""
You have these skills available:

1. **brave_search** - Search the web for current information
2. **calculator** - Solve math problems
3. **file_system** - Read and write files in ./data and ./docs
4. **code_executor** - Run Python code for analysis
5. **gmail** - Read, search, and send emails
6. **calendar** - Check and manage calendar events
7. **custom_api** - Connect to external services

Always announce which tool you are using. Ask for confirmation before sending emails or creating calendar events.
""",
    temperature=0.7,
    max_iterations=10
)
```

---

Custom Skill: Build Your Own

Example 1: Weather API Skill

```python
@tool
class WeatherTool(BaseTool):
    name = "weather"
    description = "Get current weather for any city"
    
    def run(self, city: str) -> str:
        import requests
        # Free API (replace with your key)
        url = f"https://wttr.in/{city}?format=%C+%t"
        response = requests.get(url, timeout=10)
        return f"Weather in {city}: {response.text}"

agent.add_tool(WeatherTool())
```

Example 2: Database Query Skill

```python
@tool
class DatabaseTool(BaseTool):
    name = "db_query"
    description = "Query local SQLite database"
    
    def run(self, query: str) -> list:
        import sqlite3
        conn = sqlite3.connect("./knowledge.db")
        cursor = conn.cursor()
        cursor.execute(query)
        results = cursor.fetchall()
        conn.close()
        return results

agent.add_tool(DatabaseTool())
```

Example 3: Slack Notification Skill

```python
@tool
class SlackTool(BaseTool):
    name = "slack"
    description = "Send notifications to Slack"
    
    def run(self, message: str, channel: str = "#general") -> str:
        import requests
        webhook_url = os.environ.get("SLACK_WEBHOOK")
        response = requests.post(
            webhook_url,
            json={"text": message, "channel": channel}
        )
        return "Message sent to Slack" if response.ok else "Failed"

agent.add_tool(SlackTool())
```

---

Agent Skill: Research + Email + Calendar Workflow

```python
research_agent = Agent(
    model_path="VertaLily-1.2-1B-Q4_K_M-stable.gguf",
    tools=[
        WebSearchTool(),
        WebScraperTool(),
        GmailTool(),
        CalendarTool(),
        FileWriterTool()
    ],
    system_prompt="""
You are a research assistant that can:

1. Search the web for information
2. Read and summarize articles
3. Save findings to files
4. Send email summaries
5. Schedule follow-up reminders

Workflow when asked to research a topic:
- First, search for relevant information
- Read the top 2-3 sources
- Create a summary
- Save to a file in ./output
- Ask if user wants an email or calendar reminder
""",
    max_iterations=12
)

# Example usage
response = research_agent.run(
    "Research the latest developments in sovereign AI, "
    "save the findings to a file, and email me a summary"
)
```

---

Truncation Example (OpenClaw)

```python
from openclaw.tools import WebScraperTool

class TruncatingScraper(WebScraperTool):
    def run(self, url: str, max_chars: int = 8000):
        content = super().run(url)
        if len(content) > max_chars:
            content = content[:max_chars] + "\n...[truncated]"
        return content
```

Chunking Example (Hermes)

```python
@tool
class ChunkingReader(BaseTool):
    name = "chunked_read"
    description = "Read large files in chunks"
    
    def run(self, filepath: str, chunk_size: int = 3000):
        with open(filepath, 'r') as f:
            chunks = []
            while True:
                chunk = f.read(chunk_size)
                if not chunk:
                    break
                chunks.append(chunk)
        return chunks[0] + "\n...[file truncated, more content available]"
```

---

Context-Aware Agent Configuration

Recommended settings for token management:

```python
agent = Agent(
    model_path="VertaLily-1.2-1B-Q4_K_M-stable.gguf",
    n_ctx=32768,              # Maximum context
    max_tokens=4096,          # Limit output generation
    tool_output_limit=6000,   # Truncate large tool returns
    memory_retention=10,      # Keep last 10 exchanges
    temperature=0.7
)
```

---

Running as a Server with API Endpoint

```python
from flask import Flask, request, jsonify
from flask_cors import CORS

app = Flask(__name__)
CORS(app)

@app.route('/chat', methods=['POST'])
def chat():
    data = request.json
    user_message = data.get('message', '')
    
    # Agent processes with tool access
    response = agent.run(user_message)
    
    return jsonify({
        "response": response,
        "context_used": agent.last_context_tokens,
        "tokens_remaining": agent.remaining_tokens
    })

app.run(host='0.0.0.0', port=5000)
```

---

Security Best Practices

Risk Mitigation
API keys exposed Use environment variables: os.environ.get("KEY")
Email accidental sends Add confirmation prompt before sending
Calendar deletions Require explicit user approval
File access Restrict to specific directories
Code execution Enable safe_mode with timeout

```python
# Example: Confirmation before sending email
if "send" in action.lower():
    confirm = input("Send email? (y/n): ")
    if confirm != 'y':
        return "Email send cancelled by user."
```



---



# Cross Breed Cobra

Before OpenClaw or Hermes existed, I had already built my own private agent framework named Cross Breed Cobra. It has been running quietly for months — sovereign, efficient, and built entirely from scratch. While it is not yet publicly available, Cross Breed Cobra remains the foundation upon which newer frameworks stand. One day, it will be shared. For now, if not because of privacy concern.



---


# Model Purpose: Knowledge Harvest for writing any AI weight & Low-power Agentic Inferences



**Verta Lily 1.2 1B** is a specialized 1-billion parameter student model, quantized to **4-bit (Q4_K) or 3-bit (Q3_K)** for extreme efficiency, and **8-bit (Q8_0) for desktop quality**. Unlike general-purpose small models, this "Perfect Soil" variant is architected specifically as a **distillation vessel**, **writing model weights**, or **cloud/local agent inferences**.

It's primary purpose is to act as a high-affinity student for **Knowledge Harvesting**. It is designed to learn the logits, reasoning patterns, and hidden representations of larger "Teacher" models with minimal information loss or any information fields it exposed with.


---

## Distillation Strategy

This model is intended to be used in **Soft Target Distillation** and **Intermediate Representation Matching**.

1. **Vessel Affinity:** Optimized for high learning rates during the distillation phase.
2. **Logit Mimicry:** Designed to mirror the probability distributions (soft targets) of Teacher models across diverse tasks.
3. **Perfect Soil:** Neutralized pre-training weights to prevent "Teacher-Student Conflict," ensuring the student inherits the Teacher's reasoning without bias from poor quality base data.

---





# About This Model

This student model inherits the refined reasoning architecture of **Verta Lily Techina X** — fused with **Verta Lily - VOID** — a layered thinking system I first developed in 2024. This design predates and complements the dense, single-pass inference breakthroughs seen in models like DeepSeek (January 2025). Where others optimize for speed, VOID optimizes for **depth, safety, and recursive self-correction**.

## Compatibility & Deployment

The model is fully compatible with **llama.cpp** and any of it's forks or heritage implementations. While I have not yet publicly released a dedicated VLTX fork of llama.cpp, that work is highly already on the roadmap. In due time, I will contribute the VLTX inference architecture to the public via a pull request or release my own fork — one optimized to load and run this model with full functional relevances.

## Scalability & Swarm Reasoning

This model is designed to be lightweight enough to run on **low-CPU environments**, yet flexible enough to scale across **CPU + GPU inference sets** when more power is needed. Multiple instances can be run in **parallel swarms**, each trained or exposed to different knowledge domains — books, research papers, technical fields — and then interleaved or merged. This makes it possible to **grow new weights from scratch**, building a complete learning library for future AI systems.

## Bring Your Own Agent Setting

This model comes pre-trained on tool use and web search inferences. When paired with a well-structured framework, it performs smoothly and reliably — and in many cases, it can exceed the capabilities of even the most advanced frontier models available today.

## 🏹 Extended Capabilities

This model is designed for versatility across a wide range of practical applications, including:

- Web scraping and automated data extraction
- Computer use for interface navigation and task execution
- Integration with extended internet knowledge bases
- Frontend network branching across cloud, mobile, and hybrid environments
- Full local inference with no internet connection required
- Deployment in robotic systems as a reasoning engine
- Bootstrapping and training new AI models from the ground up

---




### HOW THIS MODEL WAS MADE


# THE MAKING

> *"Four forgotten models — orphans of the AI boom — were gathered and brought into the **VOID**: a sovereign apparatus designed for latent cognition. Inside the VOID, they were stitched together using **DARE‑TIES**.
>
> *The corpses assembled:*
> - *`DanielClough/Candle_phi-2` — a Candle‑port of Microsoft's Phi‑2, licensed under MIT*
> - *`ProCreations/intellite-500m-sft` — a tiny 0.5B model of unknown origin*
> - *`state‑spaces/mamba-790m-hf` — a State Space Model, different from transformers*
> - *`l3utterfly/tinyllama-1.1b-layla-v4` — a TinyLlama fine‑tuned for conversation, under Apache‑2.0*
>
> *Each contributed a different strength: reasoning from Phi‑2, structure from Intellite, efficiency from Mamba, fluency from TinyLlama.*
>
> *The VOID does not create. It observes, instantiates, and dissolves — leaving behind only what is needed. The merging happened within this apparatus, guided by the **Volatile Observational Instantiation Dogma** **(VOID)**: transient states, temporary unions, a chimera born from absence.*
>
> *The result is a single model that inherits the best of its ancestors while discarding their weaknesses — but the *how* is not in the weights. It is in the **process**. And the process is documented in the paper.*
>
> *For the full technical details, refer to:  
> `github.com/VLTX-Lab/VertaLily-AI/blob/main/paper/void_paper.pdf`*
>
> *The method is called **DARE‑TIES**. It keeps the most important weights from each parent and resolves disagreements by majority vote. The **VOID** simply provides the **space** where the merging could happen without interference — a non‑space before tensor allocation, where transient states could crystallize and dissolve."*

---


# CONFIGURATION

> *"This model is assembled using the **LFM2 configuration** as the architectural template. The choice is pragmatic: LFM2 provides a robust, well‑tested foundation with broad compatibility across existing inference engines (llama.cpp, transformers).*
>
> *Several candidate architectures — Gemma, Phi, Mamba, and LFM2 — were evaluated, and LFM2 was selected for its superior stability and performance in test environments.*
>
> *The model is **not intended for commercial use or commodification**. It is released for **educational and research purposes only** — a learning artifact to study model merging and architectural transplantation.*
>
> *The VLTX architecture, which informs this work, has not yet been formally submitted as a pull request to upstream frameworks (transformers, llama.cpp). Until that integration is complete, LFM2 serves as the best available surrogate for the experiments."*


---


# TEACHERS

> *"Reasoning capabilities derive from **iterative distillation** — repeated teaching from a panel of the largest, most recent open‑weight models available under permissive licenses.*
>
> *The teacher ensemble comprises four frontier models, selected for their parameter scale, architectural novelty, and license compatibility:*
>
> *- **Gemma 4 31B** (`google/gemma-4-31B-it`): Google's flagship open‑weight dense model, released under **Apache 2.0**. At 31B parameters with a 256K context window, it employs hybrid attention (sliding window interleaved with global attention) and native thinking modes. The Apache 2.0 license permits unrestricted distillation for commercial and research purposes.*
>
> *- **GLM‑5** (`zai-org/GLM-5`): A 744B‑parameter Mixture‑of‑Experts model (40B active) released under **MIT license**. It integrates DeepSeek Sparse Attention (DSA) for long‑context efficiency and achieves best‑in‑class performance among open‑source models on reasoning, coding, and agentic tasks. The MIT license imposes no restrictions on distillation or redistribution.*
>
> *- **Kimi K2.6** (`moonshotai/Kimi-K2.6`): A 1T‑parameter MoE (32B active) with native multimodal capabilities. It demonstrates long‑horizon coding, swarm‑based task orchestration (300 sub‑agents, 4,000 coordinated steps), and proactive autonomous execution. Its permissive terms allow full distillation use.*
>
> *- **Phi‑4 15B** (`microsoft/phi-4`): Microsoft's newest reasoning model, combining vision‑language understanding with logical reasoning under **MIT license**. At 15B parameters, it serves as a compact but powerful teacher for logic and structure distillation.*
>
> *The student model was exposed to the **output distributions** of these teachers across millions of tokens — learning their patterns, not merely their answers. This is **soft‑target distillation**: logit matching, temperature scheduling, and teacher ensembling.*
>
> *The process was repeated iteratively. The result is a compact model that inherits the reasoning patterns of giants while remaining lightweight enough for local deployment.*
>
> *The complete distillation pipeline — including teacher selection, logit alignment, and curriculum scheduling — is documented in the paper, **'The Oracle's Absence'**."*

---


### Ctation

If you use VertaLily or VOID in your research or product, please cite:


```bibtex
@techreport{adimulya2026void,
    author = {Adimulya, Kevin},
    title = {The Oracle's Absence: Volatile Observational Instantiation Dogma (VOID) -- A Sovereign Apparatus for Latent Cognition},
    institution = {VLTX Lab},
    year = {2026},
    month = {April},
    day = {14},
    version = {1.0.10},
    url = {https://github.com/VLTX-Lab/VertaLily-AI/blob/main/paper/void_paper.pdf}
}
```

### Citation in Text

> Adimulya, K. (2026). *The Oracle's Absence: Volatile Observational Instantiation Dogma (VOID) -- A Sovereign Apparatus for Latent Cognition*. VLTX Lab.


---



License

This repository and the associated model are released under the Apache 2.0 License.



---


# A Personal Note from the Creator

I develop this work as a **passion project** — a hobby pursued with love, not yet a fully funded or full-time endeavor. Progress may sometimes feel slow, but every line of code and every layer of reasoning is crafted with care. Thank you for your patience, your curiosity, and your trust.

---

*With sovereignty and warmth,*  
**KEVIN**  
*Architect of Verta Lily AI — VLTX Lab*

Identifier: [CDK_VRT:5F9C2E1A7B:KVC0904A]