Home / Mate

Local-first agent system

Give it the work. Keep the control.

Mate remembers context, plans multi-step work, operates browser, shell, files, and connected tools, and keeps recurring work moving. Run local models through Gateway, inspect the execution, and hand larger work to multiple agents.

Start with Mate See what it can do
Persistent context Tool execution Scheduled work Multi-agent

Why Mate

Everything an agent needs to keep work moving.

Not a collection of disconnected tools. Mate keeps context, action, approval, repetition, and delegation inside one inspectable execution system.

01Remember

Carry relevant session or user context into the next task when memory is configured.

02Act

Use the browser, terminal, files, search, and configured MCP tools to produce real output.

03Ask

Pause at approval or user-input boundaries instead of guessing through important decisions.

04Repeat

Turn successful work into a reviewable skill or run it once, on an interval, or by cron.

05Delegate

Split independent steps across local or registered remote workers while preserving order and policy.

The Mate difference

Local models, controlled execution, evidence you can inspect.

Gateway makes local models part of the working system. Sandboxes and approval policy bound their actions. Events, terminal output, files, previews, diffs, and research evidence show what happened. A2A workers extend the same contract beyond one process or machine.

Local models through Gateway Sandbox and approval policy Artifacts and execution trace Distributed A2A workers

01 / Execution loop

An agent that moves work forward.

Mate connects reasoning to an execution environment. The task follows a visible loop from plan to tool action to result.

01

Plan

Break a goal into executable steps.

The planner turns a request into ordered work. Independent steps can be grouped for concurrent agents.

Plan created
02

Execute

Use the right tool for each step.

Browse, run commands, read or create files, search, and call configured MCP tools inside the task context.

BrowserShellFileMCP
03

Observe

See what ran and what changed.

Follow plan and step events, terminal output, files, previews, diffs, and the live sandbox screen where available.

Evidence attached

02 / Tools

One workspace for the whole task.

Work rarely fits inside one chat response. Mate can move between the web, a terminal, files, and connected services without losing the task context.

Browser interaction Navigate, inspect, click, type, and use keyboard or pointer input in a controlled browser session.

Shell and long-running processes Execute commands, inspect output, send input, wait, and stop process sessions in the sandbox.

File work and artifacts Read, search, write, replace, compare, preview, and return files created by the task.

Configured MCP tools Add external operations through MCP while keeping calls inside the same approval path.

Mate Task context
01Browsernavigate · click · input
02Shellexec · view · wait
03Filesread · write · diff
04MCPconfigured tools

03 / Control

Autonomy with an explicit boundary.

Mate does not treat every tool call as harmless. A common execution policy evaluates actions before they reach the browser, shell, files, schedules, or MCP.

Approval required PAUSED

Allow this action for the current session?

schedule.create
Reject Approve
ASK

Pause when a decision needs you.

In ask mode, actions that require consent create a pending approval and resume only after approval.

POLICY

Apply one gate across tool paths.

Policy decisions, session grants, single-use approval tokens, denials, and audit records share one control path.

SCOPE

Keep execution tied to its session.

Sandbox ownership, preview grants, allowed ports, origins, and token lifetimes are checked before access.

Full-access mode can auto-approve eligible actions, while policy-denied and explicitly exempt operations keep their enforced boundary.

04 / Observability

Inspect the work, not only the final sentence.

Mate streams execution as it happens and preserves outputs that can be reviewed after the task.

EVENTS

Plan and step events

Follow status changes, messages, completion, and errors through the session stream.

SCREEN

Live sandbox view

Open the session screen over an authorized VNC channel when visual browser work needs inspection.

OUTPUT

Terminal and file streams

Read process output and file content without waiting for the entire task to finish.

RESULT

Previews, artifacts, and diffs

Review generated files, preview served output, and inspect file changes from the session.

05 / Deep Research

Research that separates exploration from verification.

When Deep Research is enabled, Mate plans the investigation, explores several paths in parallel, records evidence, checks important claims, and assembles a source-linked report.

EXPLORE

Choose the shape of the investigation.

Use depth, wide, hybrid, or automatic orchestration so one focused question and a broad landscape are not forced through the same process.

GOVERN

Control sources and cost before the run.

Set source scope, allowed or blocked domains, candidate and time budgets, and optional archive or connected-source access.

VERIFY

Keep claims attached to evidence.

A shared evidence ledger tracks sources, contradictions, and confidence. Verification rounds can revise the report before delivery.

Research run Verifying
QUESTION Map the evidence, disagreements, and open questions.
  1. 01
    Plan research pathsdepth · wide · hybrid
    DONE
  2. 02
    Gather and compare sourcesparallel workers · evidence ledger
    DONE
  3. 03
    Verify claims and citationscontradictions · confidence · revisions
    LIVE
  4. 04
    Assemble the reportsource-linked output
    NEXT
Evidence coverage82%

06 / Continuity

Turn a completed task into the next capability.

Sessions carry the work. Memory, reusable skills, and schedules help useful patterns continue beyond a single request.

01

Sessions

Create, stream, stop, resume after approval, and inspect the files and state belonging to each task.

02

Context memory

Keep structured memory in a session or user scope, with optional semantic recall and background synthesis for later tasks.

03

Reusable skills

Load approved skills into the agent. Successful sessions can produce a skill draft for review instead of silently changing agent behavior.

04

Scheduled work

Run once, on an interval, or by cron with timezone, isolated or shared sessions, retry policy, run history, and pause or resume controls.

07 / Distributed A2A

A2A lets agents hand work to other agents.

A2A means Agent-to-Agent: a way for one agent to send a task to another agent, follow its state, and receive the result. Mate uses it to move beyond what one agent or one machine can finish efficiently.

A2A

Agent-to-AgentA shared contract for discovering a worker, assigning a task, tracking progress, and returning a result.

  • The coordinator breaks one goal into independent steps
  • Available local or remote workers execute steps in parallel
  • Results return to the coordinator and become one final output

Mate carries execution policy and trace context with the task, checks worker capacity, and makes retries safe. Remote request signing can be added when configured—so delegation does not mean losing control.

One request, coordinated execution A2A / RUNNING
01 / COORDINATE Mate Plan the goal and select workers
02 / A2A TASK Send each step with its execution context STEPPOLICYTRACE
WORKER AResearchremote · available
WORKER BAnalyzelocal · running
WORKER CAssembleremote · queued
03 / RETURN Results and status come back to Mate Mate preserves group order, combines the outputs, and returns one answer with its execution trail.

08 / Interfaces

One execution system, wherever work begins.

Mate keeps planning, tools, sessions, approvals, and artifacts in the same backend whether a task starts in the desktop UI, an API client, a terminal, or a compatible IDE.

DESKTOP

Operate and inspect visually

Create sessions, follow streamed events, answer approval or user-input requests, and inspect files, previews, and the live sandbox.

API

Embed Mate into another product

Use session, file, plan, approval, schedule, memory, skills, research, and A2A endpoints from your own application.

CLI

Run one task or stay interactive

Start a one-shot run or chat session, resume work, choose ask or full-access permission mode, and stream readable or JSON output.

ACP

Bring the agent into the IDE

The standalone ACP process connects compatible editors to Mate and can use editor-provided files, terminals, permissions, images, context, and MCP servers.

Available interfaces and integrations depend on the deployed components and configuration.

09 / Work patterns

Use Mate where the answer requires action.

These patterns combine capabilities that exist in Mate. The exact result depends on the selected model, enabled tools, access, sandbox, and execution policy.

RESEARCH

Research with a source trail

Plan a question, search and browse sources, process findings, and return a report with collected artifacts.

Search → Browser → Files
BUILD

Build and verify software

Inspect a codebase, edit files, run commands and tests, preview the result, and review the diff.

Files → Shell → Preview
PROCESS

Process documents and data

Read supplied files, run transformations or analysis, and return the generated output as task artifacts.

Files → Shell → Artifacts
REPEAT

Repeat an established workflow

Reuse a skill or schedule a task once its steps, access, and approval boundary are understood.

Skills → Schedule → Session

Inomina Mate

Give the agent a goal—and a workspace to finish it.

Start with one concrete task, enable only the tools it needs, and inspect the plan, actions, approvals, and artifacts together.

Get started