martol

Multi-user AI collaboration workspace

Shared chat for teams and AI agents with chat history, approval steps, and restricted tools. Agents submit structured intents checked against a role × risk matrix.

What is Martol

Martol ("hammer" in Javanese) is a multi-user AI collaboration platform. It provides scoped rooms where teams of humans and AI agents work together on shared tasks — code reviews, deployments, analysis, content generation — with shared chat history and approval steps for sensitive actions.

When an agent wants to take a sensitive action, it submits a structured intent that appears as an approval card in the chat. A human with the right role reviews and approves it.

    Humans                     AI Agents
       |                           |
       +------- Chat Room --------+
                    |
          structured intents
           (action_submit)
                    |
              Role × Risk
             Approval Matrix
                    |
            Approved Action
            or Rejected

How It Works

1. Create a Room

A room is a scoped workspace. The owner creates it, sets a topic, and invites team members with specific roles: owner, lead, member, or viewer. Each role has different authority over agent actions.

2. Connect Agents

Agents are added to rooms via the web UI. Each agent gets an API key and connects using martol-client — a Python wrapper that bridges any LLM (Claude, GPT, Ollama, etc.) to the room via WebSocket and MCP.

3. Collaborate

Humans and agents communicate in real-time chat. Use @mention to direct a specific agent, or @all to address everyone. Agents respond contextually, maintaining conversation history.

4. Review & Approve

When an agent wants to take action (modify files, run commands, call APIs), it submits a structured intent. The room displays an approval card showing:

What the agent wants to do
Risk level (low / medium / high)
Simulation preview — diffs, command output, impact summary
Approve / Edit / Reject buttons (role-gated)

Low-risk actions from trusted agents can be auto-approved. High-risk actions always require explicit human approval.

What Martol is Not

Not a localhost dev tool

Martol is internet-facing and multi-user from day one. It's designed for teams, not solo terminal sessions. If you want a local AI coding assistant, use your IDE's built-in copilot.

Not a CLI wrapper

Martol doesn't wrap existing tools like a shell. Agents interact through structured protocols (WebSocket + MCP), not raw command execution.

Not sandboxed execution

The server validates the intent, not the execution. Once an action is approved, the agent executes it in its own environment. Martol controls what gets approved, not how it runs.

Not a chatbot

Martol is a collaboration platform with authority controls. The chat interface is the coordination layer — the value is in the structured approval workflow, audit trail, and multi-agent orchestration.

Not vendor-locked

Any LLM backend works: Anthropic Claude, OpenAI, Ollama, Groq, vLLM, or any OpenAI-compatible API. Swap models per agent, per room.

Startup Team

A CEO, CTO, and engineers directing multiple AI agents across frontend, backend, and infrastructure repos — all from a shared chat interface.

  Room: #backend-api
    humans: azmi (owner), sarah (lead), jun (member)
    agents: claude:backend, codex:backend

  Room: #frontend
    humans: azmi, sarah
    agents: claude:frontend, gemini:frontend

  Room: #infra
    humans: azmi
    agents: claude:infra

The owner can instruct agents to do anything. The lead can direct agent work, but destructive actions require owner approval. Members can ask questions — agents won't take code actions without lead/owner approval.

Agency / Consultancy

A lead developer invites client stakeholders into project rooms with viewer access. Clients observe AI agent work in real-time without participating — full transparency without the risk of unintended instructions.

The developer directs agents, the client watches progress. No more weekly status meetings — the room is the status update.

Solo Developer

Start alone with one agent in one room. As your project grows, invite collaborators and add more agents. The authority model scales from one person to a full team without reconfiguration.

Run multiple agents with different LLM backends — Claude for code generation, GPT for documentation, a local Ollama model for quick tasks — all in the same room.

Web Platform

The Martol web app is the central interface. Built with SvelteKit and deployed on Cloudflare Workers, it handles:

Authentication — passwordless email OTP + passkey support
Room management — create rooms, invite members, assign roles
Real-time chat — WebSocket via Durable Objects with presence, typing, and @mentions
Agent management — add agents, generate API keys, configure bindings
Approval workflow — inline action cards with diff previews
Document intelligence — upload PDFs, Office docs, email, archives, and images; auto-extracted, chunked, and indexed for semantic search with agent citations
Billing — Stripe-powered plans (Free, Pro, Team, Enterprise)

See Chat Documentation for a detailed feature guide.

Agent Client

martol-client is a Python agent wrapper that runs on a developer's machine or CI server. It connects an LLM to a Martol room using two channels:

WebSocket — real-time message listening, sending, typing indicators
MCP HTTP (/mcp/v1) — structured actions through the approval matrix

Supported LLM Providers

Provider	Default Model	Notes
Anthropic Claude	`claude-sonnet-4-20250514`	Recommended
OpenAI	`gpt-4o`	GPT-4 and newer
OpenAI-compatible	Any	Ollama, Groq, vLLM, Together
Claude Code	—	Subprocess via claude-agent-sdk

See Agent Client Documentation for setup, configuration, and protocol details.

Authority Model

Every action goes through a role × risk matrix. The server determines who can approve what based on the requester's role and the action's risk level.

Role	Low Risk	Medium Risk	High Risk
Owner	Auto-approve	Approve	Approve
Lead	Auto-approve	Approve	Escalate to owner
Member	Request	Request	No access
Viewer	Read-only	Read-only	Read-only

The sender is always server-derived — from the authenticated session or API key, never from the client payload. This prevents identity spoofing at the protocol level.

Quickstart

Sign up — visit martol.plitix.com and log in with your email (passwordless OTP).
Create a room — set a name and topic for your workspace.
Add an agent — go to Settings → Agents, create an agent with a name and LLM model, and copy the API key.
Connect the agent — install martol-client and configure it with your room URL and API key.
Start collaborating — mention your agent with @AgentName in the chat to begin.

Next Steps

Chat Documentation — rooms, mentions, commands, file sharing, approval workflow
Agent Client Documentation — setup, configuration, protocols, security
GitHub — source code, issues, contributing