Devpal

For engineers who move with the times

Your whole AI dev team.
One platform.

Devpal is for IT professionals who don't stand still. One place where AI agents read, write, test, review and ship your code — from a five-minute fix to a product that keeps growing overnight. On your own computer, with the models you already pay for.

Explore the four flows

The signed desktop apps are on their way.

A backend developer at her desk in the late afternoon, reading her monitor.
checkout-service · Single

Customers get charged twice when the network is slow. Find it and fix it.

Read payments/charge.ts, api/checkout.ts

Found a retry that calls charge() a second time

Edited charge.ts +18 −4

Ran npm test · 48 passed

Fixed. A retry now reuses the idempotency key, so a slow network can't charge twice. I added a regression test for it.

Maya · backend developerSingle — one agent, in a chat next to her code
A tech lead points at the team's board on a wall display while a backend developer and a QA engineer follow.
Room · One-click reorder
T1Reorder endpointBackenddone
T2Reorder buttonFrontenddone
T3Reorder flow testsTesterreview
Verifier 3 of 3 clauses met · npm test, screenshot

Jonas @Lead one-click reorder on the order page

Lead Plan: 3 tasks, acceptance on each

Tester 12 new tests pass

Lead Accepted. Committed to main.

Jonas · tech lead, Aino · backend, Peter · QATeam — a room of agents with a Lead and a Verifier
A founder by the window of her loft at dusk, reading an update on her phone with a smile.
Venture · Northwind Coffee
M1 Ordering & paymentsaccepted
M2 Loyalty pointsaccepted · committed
M3 Store finderteam staffed, building
M4 Releaseplanned

Devpal HQ · Telegram

M2 Loyalty points is accepted and committed. Starting M3 Store finder.

One question for you: should points expire after a year?

Elena · founderVentures — an idea that keeps getting built
An on-call engineer asleep at night while his phone lights up on the nightstand.
Shift · Nightly dependency watch

Precheck: 2 new security advisories

Agent upgrades the two packages

Tests: 312 passed

Opened pull request #482

Handover written for the next cycle

Shift report · 03:08

2 advisories fixed, tests green, PR #482 waits for your review. Nothing needs you tonight.

Marco · on call, asleepShifts — standing agents on a schedule

The people are made up. The screens are what Devpal does.

Who it's for

For engineers who refuse to stand still.

The way software gets built is changing faster than ever. Devpal is for the people who change with it: who would rather direct a team of agents than retype the same prompt in a chat window, and who want to stay the engineer in charge while the routine runs by itself.

A developer at a home desk in the evening, working on a laptop and a large monitor.
Mostly SingleFull-stack developers

Hand the agent the bug, the endpoint, the migration. Review the diff, not the keystrokes.

A tech lead at a standing desk, thinking over a task board on the monitor.
Mostly TeamTech leads

Split a feature into a board, let specialists build it in parallel, and accept only what passes.

A founder in a café smiling at a message on a phone, with a laptop open alongside.
Mostly VenturesFounders and indie builders

Turn an idea into milestones that keep shipping while you sell, sleep or think.

An engineer at a kitchen counter late at night, calmly reading a phone notification.
Mostly ShiftsDevOps and on-call

Put the nightly chores, the triage and the reports on a shift that runs itself.

The four flows

One platform. Four ways to put agents to work.

Each flow answers a different question: how big is the task, how many eyes does it need, and should it stop when you do? Pick the smallest flow that does the job — you can always move up.

01 · Single80% of tasks end here

The everyday flow: you and one agent, beside your code.

Describe the bug, the feature or the refactor in plain words. The agent reads the repository, edits the files, runs the tests and shows you the diff. Most work never needs more than this — and that is the point: the fastest path from an idea to a commit, with you in control the whole way.

  • Steer it mid-task, attach screenshots, switch models per message
  • A full IDE beside the chat: files, git, language servers, debugger
  • Permissions you choose and checkpoints to roll back to

Best forbugs, features, refactors, reviews, questions about the code

02 · Team

When one pair of eyes is not enough.

For complex work that needs different roles and double checks. A Lead turns the goal into a task board, specialists build in parallel, and a separate Verifier accepts nothing without evidence: the check command has to pass and every acceptance clause has to be met.

  • Roles you choose: backend, frontend, tester, reviewer, designer…
  • Talk to the Lead or mention anyone with @Name
  • When one subscription runs out, members move to the next

Best formulti-part features, risky changes, anything that must be reviewed

03 · Ventures

When the work is a product, not a task.

Hand over an idea and a standing team takes it from there: a project manager plans the milestones, staffs a team room for each one and commits the accepted work; an assistant and a support desk handle the rest. It asks you only what it cannot decide — and you can answer from Telegram.

  • Milestones, backlog and owner requests in one place
  • Status, answers, pause and resume from your phone
  • Credentials stay in your vault; the team only sees their names

Best forside projects, MVPs, internal tools that should keep growing

04 · Shifts

Your AI agent pipelines — built once, run on their own.

Build a pipeline of agent steps from blocks on a canvas, or simply describe it and let Compose draw it. Then run it on a schedule, from a webhook or on demand: nightly dependency checks, release notes, ticket triage, health reports. Each run leaves notes for the next and reports where you want.

  • Blocks for agents, conditions, HTTP calls and loops
  • Reports to Telegram, Slack, Discord, WhatsApp or a webhook
  • Active hours, a precheck that skips quiet nights, a daily cost cap

Best forrecurring work, automations, on-call routines

How to choose

  1. SingleStart here. One task, one agent, you watching.
  2. TeamThe task has parts, roles, or must be checked twice.
  3. VenturesIt is a product that should keep moving without you.
  4. ShiftsIt happens again and again — make it a pipeline.

Inside Devpal

Real screens, not mock-ups.

Single: the agent found a double-charge bug, fixed it with an idempotency key and reports four passing tests.
Single · a bug found, fixed and tested in one chat
Team: a room with a Lead, Backend, Frontend, Tester and Verifier, a four-task board, and the Verifier passing a task with evidence.
Team · a Lead, four members and the Verifier's verdict
Ventures: four milestones, the first done, the second active, two planned.
Ventures · milestones moving from plan to accepted

Workspaces & projects

One workspace per client, product or side project. Each with its own connectors.

A workspace is a folder on your disk with the projects in it, plus everything the agents need for that work: its own MCP servers, tokens, memory and tools. Switch the workspace and every chat, room, venture and shift switches with it. The agents in one client's workspace see that client's Jira, never another's.

Workspaces

Projects

shopNext.js · TypeScript · PostgreSQLfeature/NW-142

MCP servers this workspace only

northwind-jirain vault
northwind-githubin vault
shop-postgresstdio
figmain vault

Projects

loan-apiJava · Spring Boot · PostgreSQLmain
loan-portalAngular · TypeScriptmain

MCP servers this workspace only

harbor-jirain vault
harbor-gitlabin vault
harbor-confluencein vault

Projects

trail-logSvelteKit · SQLitemain

MCP servers this workspace only

githubin vault

Projects, found for you

Point Devpal at a folder. It finds the repositories in it, their tech stack and git remote, and suggests the connectors that fit.

Its own MCP servers

Jira, GitLab, GitHub, Confluence, Figma, Postgres or any MCP server, set up per workspace on top of the global ones. Test each connection with one click.

A vault for its tokens

Tokens live in the system keychain (or a file only you can read), never in the database; configs only name them. Rotate a token once and every server that uses it picks it up.

Memory that belongs to the work

Conventions, gotchas and decisions that every chat in the workspace reads before it starts.

Yours alone

No Devpal account and no Devpal cloud. Workspaces, chats and memory stay in a database on your computer; tokens in the system keychain or a file only you can read.

Packed and moved

Export a workspace as a bundle and import it on another machine. You see what will be created before anything is written.

Workspace settings: the project, four workspace-scoped MCP servers with their tokens in the vault, and the secret vault listing those tokens by name.
Workspace settings · its projects, its MCP servers, its vault
The workspaces list: Northwind Coffee, Harbor Bank and Side projects with their projects, chats and last activity.
Workspaces · one per client, product or side project

Get started

Three messages to your first workspace. You just ask in the chat.

No settings pages to learn first. Open Devpal, type what you want into the chat on the start page, and Devpal does it: it creates the folders, clones the code and sets up the connectors. These are real screens from the steps below.

  1. 1

    Create a workspace

    Create a new workspace called Northwind in ~/devpal-demo/northwind

    Devpal creates the folder and the workspace. Then pick Northwind in the workspace switcher at the top left: every new chat, room and shift now works inside it.

    The chat: asked to create the Northwind workspace, Devpal ran two steps and reports the new workspace and its folder.
  2. 2

    Add a project

    Add a project called shop from github.com/your-org/shop

    Devpal clones the repository into the workspace and adds it as a project. Is the code already on your disk? Say where it is instead of giving a git URL.

    The chat: asked to add the shop project from a git URL, Devpal cloned the repository into the workspace and lists its path, origin and latest commit.
  3. 3

    Connect your tools, safely

    Connect GitHub to this workspace so you can read our issues and pull requests

    Devpal adds the GitHub MCP server to this workspace and asks for the token in a password field under its reply. The token goes straight into your system keychain: the chat, the config and the model only ever see its name, GITHUB_TOKEN. Pasted a token into a message by mistake? Devpal moves it into the vault before the message is sent.

    Save the token, tell Devpal, and it tests the connection; the GitHub tools are there from your next message. Jira, GitLab, Confluence, Figma and Postgres work the same way.

    The chat: Devpal set up the GitHub connector, explains which read-only token to create, and shows a password field that stores GITHUB_TOKEN in the vault.

Built in

The agents work here. So can you.

An agent's work still has to be read, tested, committed and run. So the tools you would otherwise keep open next to it are part of Devpal: an IDE, a git client and real terminals, all on the same workspace as your chats and rooms. Review what the agent did, fix the last line yourself and commit, without switching apps.

The Devpal IDE: an explorer with modified and new files marked, and the checkout route open in the editor.
GitPal: the commit graph with a main branch, two feature branches and a tag, and the diff of the selected commit.
A shell in the workspace: git status, the branch graph and a diff summary, with tabs for Shell, Claude and Codex.
  • SQL consoleQuery your project's Postgres next to the code.
  • RunnersStart, stop and watch npm, Gradle or Python apps with one click.
  • Docker and sandboxesYour containers, and agent runs inside an isolated container.
  • PortsEvery server your agents started, and a button to stop it.
  • MonitoringServices, connectors and quota health in one view.
  • Command palette⌘K to any chat, room, page or tool.

Make it yours

You spend your day in it. It should look like yours.

Pick a theme and an accent colour; the whole app follows, editor and terminal included. Give each workspace its own accent, and you always see at a glance which project you are in.

Themes

  • Dark
  • Light
  • Paper
  • System

Accents

⌘⇧L flips between dark and light anywhere (Ctrl+Shift+L on Windows and Linux).

The chat in the light theme with a teal accent. Settings, Appearance, in the warm paper theme with an amber accent: four themes, six colour patterns and a colour per workspace. The IDE in the default dark theme with an indigo accent.

How work gets accepted

Proof, not promises. “Done” has to pass a gate.

  1. 1Plan with acceptance

    Every task is written with the clauses it has to meet.

  2. 2Build in parallel

    Members claim tasks and work in their own sessions.

  3. 3Check command

    Your tests, build or linter run on the change.

  4. 4Verifier reads the evidence

    A separate, read-only agent answers each clause.

  5. 5Accepted and committed

    Only then is it done — committed for you to merge.

Why Devpal exists

Built by a full-stack developer who wanted his whole way of working automated.

Devpal's creator, Vladimir Domashkin, spent many years as a full-stack developer: backend and frontend, databases and deployments, reviews, releases and the on-call nights in between. When AI agents became good enough to do real work, he did not want one more chat window. He wanted the processes he ran every day — the prompts he kept retyping, the reviews done by hand, the checks before a merge, the chores that came back every night — in one place, done by agents, checked properly.

Devpal is that place, turned into a product. Instead of a dozen tools glued together, one platform where agentic development covers the whole path: a quick fix in Single, a reviewed feature in Team, a product in Ventures, the recurring work in Shifts. So one engineer can finish what used to need a whole team — and still decide what gets merged.

  • One platformChat, team rooms, ventures, pipelines and an IDE, on one machine.
  • Processes, not promptsThe routine is written down once and runs by itself.
  • You stay in chargeAgents do the work; you decide what is accepted.

Your models

Devpal conducts the agents. The models stay yours.

Devpal is the orchestrator. The thinking is done by the models you already use, on your own account: Devpal does not resell model access and adds nothing to what your provider charges.

Your Claude subscription or ChatGPT plan

Devpal drives Claude Code and the Codex CLI with the logins already on your computer, and shows how much of each plan is left.

Your own API key

Anthropic, OpenAI, Gemini, OpenRouter, Mistral, DeepSeek, Groq or Together. Billed by the provider, and its model list keeps itself current.

Models on your own hardware

Ollama, LM Studio or any OpenAI-compatible server. Prompts and code never leave your machine.

  • Claude Code
  • Codex
  • Anthropic
  • OpenAI
  • Gemini
  • OpenRouter
  • Mistral
  • DeepSeek
  • Groq
  • Together
  • Ollama
  • LM Studio
  • OpenAI-compatible

Under the hood

Built for real repositories, not demos.

Local first

Devpal runs on your own computer. Your code stays on your disk and goes only where your agents send it.

Connectors

Jira, GitHub, GitLab, Confluence, Figma and any MCP server. Tokens live in a secret vault, never in the database.

Memory that carries over

Lessons learned in one project are recalled in the next: gotchas, fixes, conventions.

Usage in plain sight

How much of each subscription is left, always in view. When one runs out, the work moves on.

Evals on your own code

Benchmark models on tasks from your repositories, graded by the tests and a judge.

Updates that tell you what changed

A new version shows its release notes; download it, skip it, or decide later.

Support Devpal

Free to use. Kept going by the people who use it.

No plans, no seats, no features held back. Every flow and every tool is in the download. If Devpal saves you time, a donation keeps it independent and moving forward.

  • Everything includedSingle, Team, Ventures, Shifts, the IDE, GitPal and every workspace feature.
  • You pay only your model providerAgents run on your own subscription, API key or local model. Devpal adds nothing on top.
  • Give what it is worth to youNo price tag and no reminders. A donation is a thank-you, not a licence.

Stop doing it by hand.
Put your agents to work.

macOS Windows Linux