Symbio

Symbio is an innovative project designed to empower users through seamless interaction with their machines. This flexible system adapts to commands, continually learning and evolving based on user input.

MOA feature Symbio has a MOA (Mixture of Agents) mode. Instead of fine-tuning one big model for every task, the headmaster delegates bounded sub-tasks to smaller worker models via tool calls. The worker executes, and if it fails it returns to the headmaster for guidance. Once it works, a note is saved for both sides. If the same mistake repeats past the configured threshold, both the worker and the headmaster are fine-tuned: the worker learns how to execute the task, and the headmaster learns how to delegate it more efficiently.

Core Features

• Local CLI Chat: Engage with Symbio directly through a local command-line interface, making communication straightforward and efficient.
• Markdown Notes: Capture facts and notes effortlessly by saving them as markdown files in the notes/ directory for easy organization and access.
• File Management: Read, write, search, and modify files within the project directory, enhancing data manipulation capabilities.
• Sandboxed Commands: Execute commands securely in a controlled environment, allowing for temporary shell command execution and Python code snippets.
• Email Interaction: Check and manage emails using IMAP/SMTP, enabling comprehensive communication features.
• Dynamic Learning: Transform notes into actionable training data to fine-tune a LoRA adapter on the fly, improving system responsiveness.
• Structured Data Storage: Every interaction is recorded in JSONL and SQLite format, ensuring that conversations are preserved for future reference.

Quick Start Example

To get started with Symbio, follow this example command sequence:

# Create a virtual environment and install dependencies
python -m venv venv
source venv/bin/activate
pip install -r requirements.txt

# Start chatting
python main.py

Upon the first run, users will be prompted to input their names, which are saved in the config.json file for personalized interaction.

Configuration Options

The configuration file allows users to customize various aspects of the interaction:

Slash Commands

Initiate various functions swiftly through user-friendly slash commands:

Learning from Corrections

Symbio automatically tracks and learns from user corrections, saving them as markdown notes in the notes/mistakes/ directory. This feature enhances the system's learning capabilities while allowing users to retain control over training processes.

Skill feature

Symbio can learn skills on the fly. A skill starts as a simple markdown note with step-by-step instructions. As errors and corrections accumulate, they are logged in a hidden .md.health.jsonl sidecar so the note itself stays clean and readable. Once the mistake threshold is reached, the collected examples are fed into a LoRA fine-tune that creates a dedicated worker adapter for that skill — one adapter = one skill. Adapters are hot-swappable and can be archived if unused.

Use /new-skill or symb skill new to create one, /skill-adapters to list them, and /archive / /restore to manage idle notes and adapters. Proving the skill is actually in the weights

The obvious objection to "the model learned a skill" is you could have just put the steps in the prompt. symb skill eval answers that with a number instead of an argument. It runs the same task battery three times: condition steps in prompt? what it measures base no what the model already knew prompted yes the "just prompt it" baseline adapter no — stripped out what the LoRA weights hold

The adapter arm gets the exact system prompt the worker was trained under, which deliberately names the skill but withholds the procedure. If it scores above base, the procedure came from the weights, because it was never in the context.

symb skill eval "Fix wifi" symb skill eval fix_wifi --threshold 0.7 --arms base,adapter

Skill: Fix wifi (5 tasks, generated)

condition steps in prompt score coverage

base no 0/5 0% prompted YES 5/5 93% adapter no (in weights) 5/5 100%

Grading is deliberately dumb — the fraction of the skill's own step vocabulary the reply reproduces — so it cannot flatter the adapter, and every raw reply is written to the JSON report so the score can be audited by hand. A null result is reported as a null result.

Read the numbers honestly: base 0/5 does not mean the base model is useless at the task. In the run above it answered with real networksetup commands, which is arguably better — it just isn't your saved procedure. And on a two-step skill this is memorisation, which is the claim being tested but the weakest form of it. Skills with a substantial procedure give a far more meaningful delta.

By default the harness generates five task phrasings, deliberately worded unlike the training seeds so a pass means recall rather than memorised strings. Drop your own in training_data/workers//eval_tasks.json to use a real battery:

[ {"id": "no_wifi", "prompt": "wifi's dead again", "must_include": ["toggle"]}, "the network dropped, sort it out" ]

Flag Default Note --output timestamped file Where to write the JSON report --threshold 0.6 Step-coverage fraction required to pass --max-tokens 400 Max reply tokens per task --arms all three Subset of base,prompted,adapter

Because the seeds are rendered with the headmaster's chat template but a worker trains the model named in its own catalog entry, the two can drift apart after a model switch. Training now refuses to run on data tokenized for a different model rather than silently learning another model's turn markers.

Architecture Structure

The project is structured as a Python package, facilitating easy access to the main components:

.
├── main.py
├── symbio/
│   ├── __init__.py
│   ├── constants.py
│   ├── utils.py
│   ├── config.py
│   ├── store.py
│   ├── sandbox.py
│   ├── computer.py
│   ├── tools.py
│   ├── llm.py
│   ├── learn.py
│   ├── chat.py
│   └── agent.py
└── notes/

This modular architecture ensures easy adaptation and integration of new features, fostering an environment for ongoing development and user engagement.

Roadmap for Future Enhancements

Volunteers interested in contributing can focus on essential areas, such as:

1. CUDA Port: Expand compatibility beyond Apple Silicon.
2. Backend Expansion: Introduce llama.cpp support for better model handling.
3. Optimization: Refine LoRA performance and memory management.
4. Refactoring: Improve code structure and maintainability.

Explore the CONTRIBUTING.md for more information on how to get involved.