AGENTS. WORKSPACES. INFRASTRUCTURE.

Build with agents.
Ship from one place.

Give your coding agents a real workspace, the right tools, and a path to production. Deploymate brings your code, AI models, and running services together, with sharing and collaboration built in for your team.

Mate & Codex agents Connected Git providers Your model routes
ONE CONNECTED PLATFORMProduct walkthrough · illustrative data
app.deploymate.net
storefront Build the project dashboard feature/dashboard
MATE Active session
Add a project dashboard. Use the existing API and keep the app’s visual style.
Let’s build it.

I’ll inspect the repository, wire up the project data, and open a preview for review.

Read project structure
Updated page.tsx and data.ts
Started the preview server
Changes ready to reviewInspect the diff before commit & push.
Ask a follow-up…
EXPLORER
storefront
Repository connected
GitHub · feature/dashboard
page.tsxModified
1import { getProjects } from './data';
2
3export default async function Projects() {
4 const projects = await getProjects();
5
6 return (
7 <ProjectGrid projects={projects} />
8 );
9}
TERMINAL Preview server

$ npm run dev

Ready · listening on 0.0.0.0:5173

Workspace preview available

Workspace connectedFiles · Editor · Terminal · Preview
Your repositoriesGitHub · GitLab · Bitbucket · SSH
Your coding agentsMate & Codex runtimes
Your model providersRoutes, client keys & guardrails
Your application stackServices, databases & shared volumes
AGENTS THAT CAN ACT

A coding partner.
With a place to do the work.

Configure a Mate or Codex agent, give it repository context, and launch a session. Chat, inspect its changes, and work alongside it in the same workspace.

Tools that know your platform

Connect MCP servers. Built-in provider tools work with pull requests, reviews, and issues; Deploymate tools work with project services, logs, environments, and dependencies.

Skills you can make your own

Import skills from public GitHub repositories or write your own instructions. Enabled skill versions are pinned to each session.

Pick up where you left off

Save and resume session snapshots. Service-backed workspaces reuse prepared development environments while keeping each session’s changes separate.

Create your first agent
Agent configurationILLUSTRATIVE SETUP
Your development agentRepository context. Reusable instructions.
Mate Codex
RepositoryConnected Git provider
WorkspaceFiles, editor & terminals
MCP serversproviders · deploymate
SkillsBuilt-in + your own
Keep control of tool access

Configure MCP approval policies. Project permissions are checked when tools access services.

EVENT-DRIVEN AUTOMATIONS

An event starts the work.
Your agents carry it forward.

Choose an app event, select an agent, and give it a prompt. Add another agent when you need a second step, with the previous result as context.

Start with a repository event

Connect a Git provider and choose a supported event. Narrow the trigger with the repository, actor, and event-specific filters.

Give every step a clear job

Choose an agent and write its prompt. Steps run in order, passing the event and the previous agent’s result to the next step.

See how the run went

Follow run history and started, finished, or failed updates. Send lifecycle notifications to your enabled notification destinations.

Open Automations

Project permissions and configured tool approvals apply to agent work.

Example automationIllustrative example

Give a new repository a clear starting point.

Triggerrepository.created
MateStep 1

Understand the codebase

Inspect the repository. Summarize the architecture, setup steps, and gaps in the developer documentation.

CodexStep 2

Turn findings into a checklist

Use the first agent’s findings to draft an onboarding checklist. Flag assumptions and changes that need review.

Result saved to run historyNotify enabled channels
FROM PROMPT TO OUTCOME

Give each agent a practical task.

Use these examples to guide your agent prompts and review process. Git tools, project infrastructure, and service context are available according to permissions and tool approvals. Deployment and resource lifetimes follow their configured settings.

Example agent task

From an idea to a reviewed change, without losing the thread.

01

Connect the repository

Open a project or repository-backed service and launch your chosen agent with its Git context.

02

Build in the workspace

Work through the change in chat. Inspect files, use the editor and terminals, and open the running app preview.

03

Review and open a PR

Review the diff, commit and push. Connected provider tools can create a pull request and add review feedback, subject to your approval settings.

04

Deploy the change

Use branch-based auto deploy or explicitly deploy a commit. PR preview environments are cleaned up when the PR is merged or closed.

Project-scoped tools · Configurable MCP approvals · Explicit resource lifetimes
CONNECTED APP EVENTS

Bring project activity into view.

Jira, Asana, and ClickUp can discover accessible resources and set up webhooks automatically. Inspect incoming events and refresh hooks from Apps.

JiraAsanaClickUp

Agent automation triggers currently support mapped Git repository events. Product management events are available for collection and inspection; they do not yet launch agent workflows.

AI GATEWAY

Many model routes.
One front door.

Bring model access into the same platform as your agents and applications. Configure upstream routes and connect through an OpenAI-compatible API.

Route on your terms

Configure providers and custom base URLs, a default route, load balancing, and session-aware routing.

Keep access scoped

Create project or account gateways. Issue and revoke client keys without exposing upstream credentials to applications.

Make usage visible

Track tokens and configure per-key token budgets and guardrails. Manage route and key settings from the dashboard.

Read the documentation
A familiar API
JAVASCRIPT Example · supply your own key and model
const response = await fetch(
  "https://ai-gateway.deploymate.net/v1/chat/completions",
  {
    method: "POST",
    headers: {
      Authorization: "Bearer YOUR_GATEWAY_CLIENT_KEY",
      "Content-Type": "application/json",
    },
    body: JSON.stringify({
      model: "YOUR_CONFIGURED_MODEL",
      messages: [{ role: "user", content: "Let’s build." }],
    }),
  },
);
INTEGRATIONS

Bring your tools.
Keep your context.

Connect your repositories, coordinate work from your product tools, and give agents access to the tools your team uses.

Git providers

Connect your code and work with repository events.

GitHub · GitLab · Bitbucket

Product management

Connect task events to your agent automations.

Jira · Trello · Asana · ClickUp
THE PLATFORM UNDERNEATH

Everything your project
needs to keep moving.

Agents are only part of the story. Deploymate also gives your team the services, storage, configuration, and operational context to run what you build.

Application services

Deploy public web services and private services from a connected repository. Choose resource plans, build/run commands, ports, and health checks.

WebPrivateContainers

Workers & scheduled jobs

Run background workers and cron jobs alongside your application. Keep code, environment configuration, and deployment history in one project.

WorkersCron jobs

Databases & caches

Add PostgreSQL and Valkey services with persistent storage and connection details. Use them from your project’s application services and agent workflows.

PostgreSQLValkey

Stateful apps & shared volumes

Give a stateful service its own disk, or attach project volumes across workloads. Browse files, download folders, and preview supported media in the volume explorer.

Persistent disksFile explorer

Build, deploy & preview

Build from GitHub, GitLab, Bitbucket, or SSH. Follow a branch, pin a commit, and inspect deployment history. PR previews live only while their PR is open.

Auto deployCommit pinningPR previews

See what’s happening

Inspect service and build logs, deployment events, CPU and memory metrics, and running pods. Open a pod terminal and configure notifications and log destinations.

Logs & metricsPod shell

Configuration that stays organized

Manage environment groups and secret files, attach configuration to services, and control service agent setup commands and watched dependency files.

Environment groupsSecret files

Collaborate with clear boundaries

Invite collaborators to a project or across an account. Grant Read, Create, or Write & deploy permissions; tools check access to the resources they use.

Project accessAccount access

Code without a running deployment

Create a Codebase for a connected repository and work with an agent before deploying anything. Review code and connect your Git provider through Apps.

CodebasesApp integrations
CPU and memory autoscaling for eligible workloads Service and agent pod-hour visibility Project-scoped access checks
COLLABORATION & TEAM SHARING

Bring your team.
Share the work, with clear access.

Invite teammates into a project or across your account. Keep agents, sessions, and the resources behind your work accessible to the right people.

Share a project or your account

Invite people by email. Choose a single project, or grant global access to account-owned resources, including future projects and sessions outside projects.

Keep the workspace in context

Give collaborators access to project agent sessions and their workspaces. Session viewing and interaction follow the permissions you grant.

Choose what each teammate can do

Set Read, Create, or Write & deploy access. Fine-tune permissions for agents, apps, gateways, automations, and services, then update or revoke access as your team changes.

Build with your team

Manage invitations and access in Settings → Users.

A FEW PRACTICAL DETAILS

Built for how
development really works.

Understand the workspace, the tools, and the resource lifetimes before you get started.

How do I share work with my team?

Open Settings → Users to invite a teammate by email. Share one project, or choose global access to account-owned projects and sessions, including future projects. Set Read, Create, or Write & deploy access and refine it for agents, apps, gateways, automations, and services. Owners can update or revoke collaborator access.

How do event automations work?

Choose a supported app event, add any repository or event filters, then select an agent and write its prompt. You can add ordered agent steps; each receives the original event and the preceding result. Run history records progress, and enabled notification destinations receive started, finished, or failed updates. Configure the provider webhook to deliver the selected events.

Can Jira, Asana, or ClickUp events launch agents?

These integrations currently support automatic resource discovery, webhook setup, and incoming event inspection in Apps. Agent automation triggers currently support mapped Git repository events. Product management event-to-agent workflows are not enabled yet.

Can I work directly, or does an agent do everything?

Both. A session brings chat, files, an editor, terminals, Git controls, and running app previews into the same workspace. You can inspect changes, edit code yourself, and explicitly commit and push.

How are agent tools and skills configured?

Mate and Codex agents support MCP integrations and managed skills. Configure tool approval policies, import a public GitHub skill or write manual instructions, and enable the skills you need. Each session retains its selected skill versions.

What happens when I close an agent session?

The workspace runtime and its published routes are cleaned up. Saved snapshots support resuming the session. Session-bound project services created by the agent suspend; regular services keep running. Retained data and snapshots follow their own storage lifecycle.

What happens to a pull request preview after merge?

A merge or close event triggers cleanup of the PR’s preview workloads, builders, image repository, configuration, copied secrets, and dedicated disk. Retry handling and periodic provider checks catch failed cleanup and missed webhooks. Shared project resources remain separate.

Do I have to use one AI provider?

No. AI Gateway supports configured provider routes and custom base URLs through an OpenAI-compatible API. Route credentials, client keys, token budgets, and routing settings belong to your gateway. Model availability depends on the configured upstream provider and your account access.

Which repositories can I connect?

Connect GitHub, GitLab, or Bitbucket through a provider integration, or use SSH credentials. A Codebase lets you work with a repository and agent sessions without provisioning an application workload.

FROM FIRST IDEA TO RUNNING SERVICE

Your next project.
Meet your new workspace.

Connect a repository, choose an agent, and bring the rest of your stack along.