Skip to content

Mas-AI-Official/Daena-Coder

BranchesTags

Repository files navigation

  ██████╗  █████╗ ███████╗███╗   ██╗ █████╗      ██████╗ ██████╗ ██████╗ ███████╗██████╗
  ██╔══██╗██╔══██╗██╔════╝████╗  ██║██╔══██╗    ██╔════╝██╔═══██╗██╔══██╗██╔════╝██╔══██╗
  ██║  ██║███████║█████╗  ██╔██╗ ██║███████║    ██║     ██║   ██║██║  ██║█████╗  ██████╔╝
  ██║  ██║██╔══██║██╔══╝  ██║╚██╗██║██╔══██║    ██║     ██║   ██║██║  ██║██╔══╝  ██╔══██╗
  ██████╔╝██║  ██║███████╗██║ ╚████║██║  ██║    ╚██████╗╚██████╔╝██████╔╝███████╗██║  ██║
  ╚═════╝ ╚═╝  ╚═╝╚══════╝╚═╝  ╚═══╝╚═╝  ╚═╝    ╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝╚═╝  ╚═╝

Multi-LLM coding desktop with council synthesis, MCP tools, and local-first privacy.

License: PolyForm Small Business Python Node Electron MCP

Install · Modes · Skills · MCP · Providers · License

mas-ai.co · daena.mas-ai.co

What is Daena-Coder?

Daena-Coder is a coding desktop that runs multiple LLMs in parallel and synthesizes their responses into a single, higher-quality answer.

Most coding tools are one model, one response, one guess. Daena-Coder runs a swarm of locally-hosted models from different training families, each answering independently, then synthesizes the results. When all three agree — it's reliable. When they disagree — you can see why.

Your query
    │
    ├──► qwen2.5-coder:14b ──────────┐
    ├──► deepseek-r1:14b  ──────────► Council Engine ──► Synthesized answer
    └──► llama3.1:8b      ──────────┘     │
                                           └──► [QUINTESSENCE] Expert lenses
                                                  Architect · Security · Critic

No subscriptions. No cloud. No data leaving your machine.

Install

Requirements

Tool Version Why
Python 3.11+ Backend runtime
Node.js 20+ Desktop app
Ollama Latest Local model inference

Windows

git clone https://github.com/Mas-AI-Official/Daena-Coder
cd Daena-Coder
install.bat

Linux / macOS

git clone https://github.com/Mas-AI-Official/Daena-Coder
cd Daena-Coder
chmod +x install.sh && ./install.sh

First run

# Pull models (Ollama must be running)
ollama pull qwen2.5-coder:14b
ollama pull deepseek-r1:14b
ollama pull llama3.1:8b

# Start
daena-coder setup    # one-time hardware detect
daena-coder start    # launch desktop + backend

Daily commands

daena-coder start     launch the desktop
daena-coder status    show backend and model health
daena-coder doctor    diagnose common setup issues
daena-coder stop      shut down the backend

Modes

Daena-Coder ships three reasoning modes. You pick per-conversation.

Mode What runs Best for
STANDARD Single model, direct path Quick lookups, simple edits
COUNCIL 3 models in parallel → synthesis Default. Most queries.
QUINTESSENCE Council + expert lenses (Architect, Security, Practitioner, Critic, Researcher) → meta-synthesis Complex design, security review, architecture decisions
TURBO 3 small models (≤4B) truly parallel in VRAM Fast iteration, constrained hardware
Agent Tool-using execution loop File operations, multi-step tasks, workspace automation

Default is COUNCIL. The swarm picks one model from each of three different training families (Alibaba/Qwen, DeepSeek/Mistral, Meta/Google) to maximize diversity and minimize correlated errors.

Skills

Skills are reusable prompt workflows you invoke with slash commands. Drop a .md file into skills/ and it's immediately available.

skills/
├── review.md          /review     — council-powered code review
├── security.md        /security   — OWASP-focused security audit
├── refactor.md        /refactor   — smart refactor with rationale
├── test.md            /test       — generate test cases
├── explain.md         /explain    — plain-English code explanation
├── docs.md            /docs       — docstrings and API docs
├── debug.md           /debug      — systematic debug session
├── optimize.md        /optimize   — performance profiling guidance
├── commit.md          /commit     — conventional commit message
└── pr.md              /pr         — pull request description

Writing a skill

---
name: security
description: OWASP-focused security audit for the current file or selection
mode: QUINTESSENCE
---

You are a senior security engineer. Audit the provided code for:
- Injection vulnerabilities (SQL, command, LDAP)
- Authentication and session management flaws
- Sensitive data exposure
- OWASP Top 10 coverage gaps

Provide a severity-ranked list with remediation steps.

Skills support frontmatter to set routing mode, temperature, max_tokens, and tool access.

MCP Connectors

Daena-Coder is MCP-native. Connect any MCP server and its tools appear in the tool panel automatically.

Quick setup — config/mcp_servers.yaml

servers:
  # Version control
  github:
    command: npx
    args: [-y, "@modelcontextprotocol/server-github"]
    env:
      GITHUB_PERSONAL_ACCESS_TOKEN: ${GITHUB_TOKEN}

  # File system (scoped to your workspace)
  filesystem:
    command: npx
    args: [-y, "@modelcontextprotocol/server-filesystem", "/your/workspace"]

  # Web search
  brave-search:
    command: npx
    args: [-y, "@modelcontextprotocol/server-brave-search"]
    env:
      BRAVE_API_KEY: ${BRAVE_API_KEY}

  # Memory / knowledge graph
  memory:
    command: npx
    args: [-y, "@modelcontextprotocol/server-memory"]

  # PostgreSQL
  postgres:
    command: npx
    args: [-y, "@modelcontextprotocol/server-postgres", "${DATABASE_URL}"]

  # SQLite (local databases)
  sqlite:
    command: npx
    args: [-y, "@modelcontextprotocol/server-sqlite", "--db-path", "./data/local.db"]

  # Puppeteer (browser automation)
  puppeteer:
    command: npx
    args: [-y, "@modelcontextprotocol/server-puppeteer"]

  # Slack
  slack:
    command: npx
    args: [-y, "@modelcontextprotocol/server-slack"]
    env:
      SLACK_BOT_TOKEN: ${SLACK_BOT_TOKEN}
      SLACK_TEAM_ID: ${SLACK_TEAM_ID}

Popular connectors

Connector Install What it adds
GitHub npx @modelcontextprotocol/server-github PRs, issues, code search
Filesystem npx @modelcontextprotocol/server-filesystem Read/write workspace files
Brave Search npx @modelcontextprotocol/server-brave-search Web search in agent loop
Memory npx @modelcontextprotocol/server-memory Persistent knowledge graph
PostgreSQL npx @modelcontextprotocol/server-postgres Query production DBs safely
Puppeteer npx @modelcontextprotocol/server-puppeteer Browser automation
Slack npx @modelcontextprotocol/server-slack Read channels, post messages
Linear npx @modelcontextprotocol/server-linear Issue tracking
Notion npx @modelcontextprotocol/server-notion Docs and wikis
Sentry npx @modelcontextprotocol/server-sentry Error monitoring

Providers

Daena-Coder works with any OpenAI-compatible endpoint. Configure in config/settings.yaml.

providers:
  # Local (recommended — free, private)
  ollama:
    base_url: http://localhost:11434
    enabled: true

  llama_cpp:
    base_url: http://localhost:8080
    enabled: false

  vllm:
    base_url: http://localhost:8000/v1
    enabled: false

  # Cloud (optional — for escalation when local isn't enough)
  anthropic:
    api_key: ${ANTHROPIC_API_KEY}
    enabled: false

  openai:
    api_key: ${OPENAI_API_KEY}
    enabled: false

  openai_compat:
    base_url: https://openrouter.ai/api/v1
    api_key: ${OPENROUTER_API_KEY}
    enabled: false

Secrets are never stored in config files — use environment variables or the built-in secrets manager (daena-coder setup wires this for you).

Architecture

Daena-Coder Desktop  (Electron + React + Tailwind)
  ├── Session shell with execution transcript
  ├── Provider, MCP, and skill panels
  ├── Slash command palette
  └── Composer with run controls

Daena-Coder Backend  (FastAPI + asyncio)
  ├── ChatOrchestrator        — routing, swarm dispatch, synthesis
  ├── CouncilEngine           — multi-model deliberation
  ├── QuintessenceEngine      — expert-lens meta-synthesis
  ├── AgentLoop               — tool-using execution
  ├── ProviderRegistry        — local + cloud adapters
  ├── MCPClient               — dynamic tool loading
  ├── SkillLoader             — slash commands from markdown
  └── SessionManager          — conversation persistence

Capability Layer
  ├── Built-in tools (read, write, bash, search)
  ├── MCP servers (any OpenMCP-compatible server)
  ├── Skills (markdown slash-command workflows)
  └── Extensions (local capability packs)

Repository layout

Path Purpose
backend/app/intelligence/ Council, Quintessence, swarm orchestration
backend/app/providers/ Ollama, llama.cpp, vLLM, Anthropic, OpenAI adapters
backend/app/mcp/ MCP client — dynamic tool registration
backend/app/tools/ Agent loop, tool executor, built-in tool definitions
backend/app/skills/ Skill loader — markdown → slash commands
backend/app/sessions/ Conversation state and persistence
cli/ daena-coder launcher CLI
desktop/ Electron + React + Vite desktop app
skills/ Built-in and user skill files
config/settings.yaml Providers, MCP servers, routing config

Recommended model stack

Tested on 8 GB VRAM (TURBO mode — true parallel):

ollama pull qwen2.5-coder:3b    # coder, fast
ollama pull deepseek-r1:7b      # reasoning
ollama pull llama3.1:8b         # general

Full quality (16+ GB VRAM or sequential swap):

ollama pull qwen2.5-coder:14b   # best local coder
ollama pull deepseek-r1:14b     # best local reasoning
ollama pull llama3.1:8b         # diverse distribution

Privacy

  • Sessions are stored locally in data/sessions/
  • Local providers run entirely on your hardware — no data leaves
  • API providers are opt-in and clearly labeled in the UI
  • MCP tools show which external services they connect to
  • Desktop-control access requires explicit enable in settings

Security issues: email security@mas-ai.co

License

Daena-Coder is licensed under PolyForm Small Business 1.0.0.

Plain English:

You Can use this?
Individual developer Yes, free
Startup / small team (<100 people, <$1M revenue) Yes, free
Large company or enterprise No — contact us for a commercial license

This is intentional. The intelligence backend — council synthesis, expert-lens deliberation, swarm routing — is the core innovation. We want the community to have real source access and fork rights. We do not want large organizations to absorb the architecture into a commercial product without a separate agreement.

Read the full terms: LICENSE · LICENSING.md

Commercial licensing

If your organization exceeds the PolyForm thresholds, contact MAS-AI for commercial licensing terms.

If you want the full governed platform — council + quintessence + Shield governance + 10 departments + 5-tier memory + multi-tenant — that's Daena.

Built by MAS-AI Technologies Inc. · mas-ai.co

Want the full governed AI platform? → daena.mas-ai.co

Not affiliated with or endorsed by Anthropic, OpenAI, Google, Meta, or any model vendor.

About

Free multi llms local swarm

Resources

Readme

License

MIT license

Code of conduct

Code of conduct

Contributing

Contributing

Security policy

Security policy
Activity
Custom properties

Stars

2 stars

Watchers

0 watching

Forks

0 forks
Report repository

Releases 1

Daena-Coder v0.1.0 — Initial Public Release Latest
Apr 24, 2026

Packages

 
 
 

Contributors

Languages