See how Swarmix works

Icons for Home, Projects, Agents, Plans, Knowledge, Artifacts, Marketplace, Analytics, and Settings. Everything is one click away.

Each project links to a local folder. The context panel shows the project name, path, active agents, and session history.

Each agent combines: an AI provider and model, a role (persona and constraints), available tools, and a permission level that controls how much autonomy the agent has.

Choose from Supervised (agent asks before every action), Assisted (file changes allowed, commands need approval), or Autonomous (full freedom). Your organisation can restrict which levels are available.

Every message, action, and result is recorded. Action groups are collapsible. You see exactly what the agent did and can approve or reject at any point.

Sensitive information is automatically detected and masked before anything leaves your device. This runs locally and cannot be bypassed.

An AI-driven controller that breaks your request into steps, routes each step to the best-fit agent, and manages the handoff between agents.

Before one agent passes work to another, a gate checks that the output is complete and the next agent is ready. You can require manual approval at each gate.

Start with archetypes like Coder, Architect, Security Auditor, Technical Writer. Each includes a persona, expertise triggers, and behavioural constraints.

Roles can explicitly block specific tools (e.g., prevent a read-only reviewer from running commands). This is enforced before the AI even sees the tool. No override possible.

Agents share findings on a conversation board. Proposals require consensus from team members before proceeding. The governance layer ensures each agent stays within its defined scope.

Structured plans with phases, deliverables, and quality gates. Tickets track bugs and action items. Both link to conversation threads for full context.

Read and write operations for common office formats. Agents can extract tables from Excel, read PDF content, and generate Word documents.

Drop files into the chat. The agent processes them locally. Large files are handled in chunks. Results stay on your machine unless you explicitly share them.

Key decisions and findings from conversations are automatically surfaced as draft articles for review. Accept, edit, or discard.

Articles move through Draft → Review → Approved → Archived. Each stage has ownership, ratings, and full edit history. Approved articles become the team reference.

Activity tracking captures response times, active sessions, and error rates. Connect to your existing monitoring platform for dashboards and alerts.

Each conversation shows a chronological view of messages, actions, approvals, and cost. Filter by agent, project, or date range.

The desktop app syncs policies from the central server on every connection. Blocked features are disabled in the interface. Policy violations are logged and can trigger alerts.

Connect your identity provider (Okta, Azure AD, OneLogin). Users and groups sync automatically. When someone leaves the organisation, their access is revoked according to your chosen strategy.

Desktop application on the user's machine. Handles the interface, local file access, and agent process management. No inbound network ports.

Organisation-level server. Manages configuration, user membership, policy distribution, and identity provider integration. The single source of truth for organisational policy.

Docker Compose for single-VM. Helm chart for Kubernetes. PostgreSQL for state. All configuration via environment variables. Health endpoints for load balancer probes.

Clients connect to Hive over WSS (port 443). Hive connects to Orchestrator internally. No direct client-to-orchestrator traffic. All traffic encrypted in transit.

Each organisation is fully isolated. Provisioning in one organisation never creates membership in another. External identifiers are scoped per-organisation. Seven hard isolation rules enforced.

Tested with Okta, Azure AD, and OneLogin. Supports bulk operations (up to 100 at once) and all standard identity provider sync patterns.

Google and Microsoft OAuth, SAML 2.0, and OpenID Connect supported. Sessions carry organisation context. Revocation is immediate.

Admins generate and revoke provisioning tokens, view token health alerts, and configure offboarding strategy per organisation.

Admin sets policy in Hive. Hive distributes to clients. The client merges organisational rules with local configuration. Blocked features are greyed out. Violations are logged.

Block autonomous mode, restrict model selection (e.g., only specific models), enforce data protection, control external tool connections, limit file system access patterns.

Structured patterns (card numbers, national IDs, email addresses) are caught by pattern matching. Unstructured sensitive data (names in context, addresses, medical terms) is caught by the AI detection model. Both run before the message leaves the client.

Organisational policy can make data protection mandatory. When enforced, users cannot disable it. The protection indicator is always visible in the chat header.

Active sessions, tool invocation latency, total invocations, provisioning and offboarding events, authentication failures, and request duration. All metrics carry organisation labels for per-tenant dashboards.

Export to Grafana, Jaeger, Datadog, or any compatible collector. Standard configuration, no code changes required.

Deactivate (default): soft-delete membership, user can be re-provisioned later. Full Remove: remove from all groups, delete project memberships, delete organisation membership, revoke all sessions.

All provisioning and offboarding events are audit-logged with timestamps, actor, and affected resources. Metrics track event counts by organisation.

Projects bind to a local directory. The agent's file read/write/edit tools are scoped to this path. Git status and recent commits are available in context.

Resume interrupted sessions. The resume dialog shows previous sessions with their last message and context, so you can pick up where you left off.

Each agent has a toolkit: the set of tools it can invoke. Add tools from the marketplace or configure custom tool servers. Tools run as local subprocesses.

Supervised: agent asks before every action. Assisted: file edits allowed, shell commands require approval. Autonomous: full freedom. Choose per agent.

Related tool calls collapse into groups (e.g., "5 file reads"). Expand to see details. Each call shows the tool name, arguments, result, and timing.

Files created or modified by the agent appear as artifacts linked to the conversation. Browse, diff, and manage them from the artifacts panel.

The conductor analyses your prompt and generates a step-by-step plan. Each step is assigned to an agent based on its role and tools. You can edit the plan before execution starts.

When agent A completes its step, a handoff gate validates the output before passing to agent B. Gates check completeness, tool availability, and can require your approval.

Plans contain phases. Phases contain items. Items have status (pending, active, completed, blocked), acceptance criteria, and linked artifacts. Gates validate phase completion.

When work diverges from the plan, record a diversion with the reason. Memos park out-of-scope items for later. Full version history tracks every plan change.

Tickets have status transitions, priority, labels, and assignees. Dependencies track blockers. Subtasks break large tickets into manageable pieces.

Link tickets to external trackers (Jira, Linear, GitHub Issues). Pull latest state from the tracker. Two-way sync keeps both systems current.

The Knowledge Intelligence plugin scans conversation transcripts and surfaces candidate knowledge articles. Accept, edit, or discard extractions. Good ones become team reference.

Knowledge articles link to each other and to conversations, tickets, and plan items. The context view shows all related docs and links for any entry.

Each plugin lives in its own directory with its own package, migrations, tools, routes, and optional frontend. Plugins import only from the core package, never from the server or other plugins.

Core services communicate with plugins through a broadcast event system. Plugins receive events (document created, proposal resolved, ticket transitioned) and react independently. Failures are isolated.

Organisation → Projects → Agents. Each level has its own access controls. Organisation-level policies cascade to all projects and agents below.

Admins manage user membership, configure identity provisioning, set offboarding strategy, define policy rules, and monitor compliance. All admin actions are audit-logged.

Agents check whether a topic is within their defined scope before acting. If it falls outside, they escalate to involve the right agent automatically.

A registry shows which agent owns which domain. Clear ownership prevents overlapping work and ensures accountability.

Layer 1: catches structured patterns with known formats. Layer 2: an AI model catches context-dependent sensitive data that patterns alone would miss. Both run before the outgoing message.

Organisational policy can make Data Shield mandatory. When enforced, it cannot be disabled by the user. The chat header always shows protection status. Violations are logged.

Org Policy (broadest): blocks features and models. Role: restricts tools, file patterns, and actions. Permission Level (narrowest): Supervised, Assisted, or Autonomous. Each layer can only restrict, never widen.

Roles can explicitly block specific tools. The client enforces this before the AI sees them. Even in autonomous mode, blocked tools cannot be called. This is the hard boundary.

The transcript captures: who sent each message (user or agent), which tools were called with what arguments, what each tool returned, whether the user approved or rejected, and the final result.

Built-in instrumentation captures tool invocation latency, error rates, active sessions, and provisioning operations. All metrics carry organisation labels for per-tenant dashboards.

Soft-deletes the organisation membership. User can be re-provisioned later. Group memberships and project access are preserved but inactive.

Hard-deletes: removes from all groups, deletes project memberships, deletes organisation membership, revokes all active sessions. Immediate and complete. Audit log retained.

Draft: author writes and edits freely. In Review: submitted for peer review. Approved: officially blessed, searchable reference. Archived: marked outdated, replaced by newer content.

Full edit history on every document. Ownership transfers are logged. Ratings and quality audits provide ongoing quality signals.