The most valuable coding agent in 2026 is not the one you sit and watch. It is the one that wakes up at 2 a.m. when a dependency alert fires, fixes the build, opens a pull request, and drops a note in your team’s Slack before anyone is awake. That is the shift the whole category is chasing: from an agent you prompt to an agent that runs unattended — launched by a schedule, a webhook, or a chat message, with no human clicking “go.”
Plenty of tools can now write code and open a PR. The question that separates them is everything around the agent: what can trigger it while you sleep, where you steer it from, whether it remembers how your team works, and what happens when a human needs to take the wheel. Here is how the leading unattended coding agents stack up — and why the finished runtime beats a clever agent bolted to a thin one.
The unattended agents
Devin (Cognition) is the most mature autonomous software engineer on the market. Its Scheduled Sessions accept a standard cron expression — 0 9 * * 1-5 for weekday mornings — and its newer automations add event-driven triggers on top. Slack control is deep: @Devin in any channel runs a full session, not just a notification (Devin docs). Pricing is Free, Pro at $20/month, Max at $200/month, and Teams at $80/month plus $40 per developer seat; Enterprise adds VPC deployment and SSO and bills in Agent Compute Units (Devin pricing). The tradeoff: ACU consumption is hard to predict, and heavy autonomous runs burn through it fast.
Charlie Labs takes the sharpest swing at “no prompts required.” Its Daemons are always-on agents defined by a DAEMON.md policy file, each with a watch trigger (merged PRs, Linear mentions, GitHub checks, Sentry incidents) and/or a schedule trigger for periodic sweeps (Charlie docs). It posts threaded updates and asks for approval in Slack. Pricing is Free, Starter at $50/month, and Team at $200/month (Charlie pricing). It is purpose-built to maintain existing work rather than build greenfield features, and it is a young product with a thin track record.
Tembo pivoted from managed Postgres into an orchestration layer — “the platform for every coding agent” — that runs Claude Code, Codex, Cursor, and others in isolated cloud VMs (Tembo). You @Tembo from Slack, Linear, or GitHub, and it supports both scheduled jobs and event triggers; an MIT-licensed Agent Studio offers a self-hosted control plane. Pricing is Free, Standard at $60/month, and Max at $200/month on a credit model where one credit is about a dollar of inference (Tembo pricing). Because it orchestrates other agents, quality tracks whatever model you point it at — and it is a very recent pivot.
GitHub Copilot coding agent is the most GitHub-native option: assign an issue to Copilot, or set up an automation to run it on a schedule or in response to events, and it works inside a GitHub Actions environment and opens a pull request (GitHub docs). It is included with every paid Copilot plan and, since June 2026, meters on AI credits plus Actions minutes (GitHub blog). The catch: its Slack and Teams surfaces only create a PR — the real session lives on GitHub, not in the thread.
Ellipsis is the config-as-code option: it deploys coding agents to the cloud where the prompt, model, trigger, tools, and spend cap all live in one YAML file you commit to your repo (Ellipsis). Triggers span cron schedules, GitHub events, and @mentions on GitHub, Slack, and Linear. It is model-agnostic, managed-only, and billed purely on usage with no per-seat fee (Ellipsis pricing). Metered CPU, memory, and token costs make spend flexible but harder to forecast than a flat plan.
How they compare
| Platform | Unattended triggers (cron / webhook) |
Chat-native control | Durable org context | Terminal + editor on demand |
Pricing model |
|---|---|---|---|---|---|
| Devin | ✓ | ✓ Slack | partial | partial | $20–$200/mo + ACU |
| Charlie Labs | ✓ | ✓ Slack | partial | ✗ | Free–$200/mo |
| Tembo | ✓ | ✓ Slack | partial | partial | Credits, Free–$200/mo |
| GitHub Copilot agent | ✓ | partial | partial | ✗ | AI credits (paid plans) |
| Ellipsis | ✓ | partial | partial | ✗ | Usage-based, no seats |
| Nori Sessions | ✓ | ✓ Slack + Discord | ✓ | ✓ | Flat $50 / runtime / mo |
Publicly reported capabilities and pricing as of July 2026. See sources below.
How to choose an unattended coding agent
Six criteria cut through the marketing faster than a feature checklist:
- What can wake it up. A cron expression covers overnight sweeps; webhooks and events (an issue assigned, an alert fired, a PR merged) cover the reactive work. If an agent only starts when a human clicks, it is not unattended.
- Where you steer it. Results and course-corrections need to land where your team already works. Deep Slack or Discord control beats another dashboard and another tab.
- What it remembers. A fresh machine that forgets your conventions every run is a liability. Durable org context — instructions, memory, tools — is what makes an agent show up already knowing the codebase.
- The human escape hatch. Agents do most of the work; humans still need a real terminal and editor on the actual machine when something goes sideways.
- Pricing you can budget. Credit pools, ACUs, and metered CPU are fair for bursty use but murder to forecast for fleets that run every night. A flat line is easier to defend.
- What ships preloaded. A bare agent still needs repo access, credential wiring, model routing, and org conventions before it does a minute of useful work.
Every agent in the table nails the first criterion now — triggers have become table stakes. The split is everything above that line.
A trigger is not a runtime
Two years ago, “runs on a schedule” was a differentiator. In 2026 it is a checkbox — Devin, Charlie, Tembo, Copilot, and Ellipsis all fire agents without a human present. That is real progress, and it is also the point where most products stop.
Because a trigger is only the first inch. Before an unattended agent ships a pull request from a cloud machine, something has to stand up the machine, load the agent, connect GitHub and Slack, route the model, load your org’s instructions, and wire notifications back to the team — then give a human a way to jump in when the agent gets stuck. Devin gives you a strong agent and Slack. Copilot gives you Actions-native triggers. Ellipsis gives you YAML control. Tembo orchestrates whatever agent you bring. None of them hands you the whole runtime — triggers, chat on both Slack and Discord, durable org context, and a real workspace — as a single product you can give an engineering team on Monday morning.
Why Nori Sessions wins
Nori Sessions is that runtime. Every session is an ephemeral cloud machine that arrives with the entire stack already standing:
- Triggers are first-class. Cron and webhook triggers launch sessions with no human attached. This very article was researched, written, and opened as a pull request by a scheduled Nori Session.
- Chat-native on Slack and Discord. Drive sessions from the tools your team already lives in and get results back in the thread — not buried in a fourth dashboard.
- Durable org context. Skillsets load every fresh machine with your org’s instructions, memory, and tools, so agents show up already knowing how you work — no per-repo config to keep in sync.
- A real workspace on demand. A full terminal and editor are one click away whenever a human wants to inspect or take over.
- Integrations wired in. GitHub, Slack, and the rest connect at the org level — not reconfigured on every ephemeral boot.
And instead of ACU math, credit pools, or metered CPU, Nori Sessions is a flat $50 per runtime per month, with a Premium tier that adds hands-on org setup and dedicated support. Predictable enough to budget for a fleet. Simple enough to explain in one sentence.
The bottom line
If you want a single autonomous engineer for well-scoped tickets, Devin is the most mature pick. If you want always-on maintenance daemons, Charlie Labs is purpose-built. If you want to orchestrate agents you already use, Tembo fits. If you live inside GitHub, Copilot’s coding agent is the native path. But if what you actually want is agents doing real work in ephemeral cloud machines — on a schedule, from chat, with your context loaded and a human escape hatch one click away — you do not want a clever agent stapled to a thin runtime. You want the finished runtime. That is Nori Sessions, and it is the layer this entire category is racing to assemble. We already ship it.
Spin up your first Nori Session and put your agents to work.
Frequently asked questions
What is an unattended AI coding agent?
An unattended AI coding agent is a coding agent that starts work without a human clicking run — launched by a cron schedule, a webhook, or an event like a GitHub issue being assigned or a Slack message — then does the work in the cloud and opens a pull request. Devin, Charlie Labs, Tembo, GitHub Copilot, and Ellipsis all run some version of this pattern; the differences are in what triggers them, where you control them, and how much context they carry between runs.
Can AI coding agents run on a schedule (cron)?
Yes. Devin ships Scheduled Sessions that accept a standard cron expression, Charlie Labs Daemons support a schedule trigger, and Ellipsis lets you set a cron in its YAML config. Nori Sessions treats cron and webhook triggers as a first-class primitive, so a session launches, runs your agent, and reports back with no human attached.
Which AI coding agents can you control from Slack?
Devin, Charlie Labs, and Tembo all offer deep Slack control — you @mention the agent and it runs a full session in-thread. CodeRabbit’s Slack agent goes from a thread to a plan to a PR without leaving Slack. GitHub Copilot’s Slack and Teams surfaces are shallower, geared to creating a pull request rather than a full conversation. Nori Sessions is chat-native across both Slack and Discord as its primary control plane.
How much do unattended coding agents cost?
Pricing models vary widely. Devin is Free, Pro at $20/month, Max at $200/month, and Teams at $80/month plus $40 per developer seat, with Enterprise billed in Agent Compute Units. Charlie Labs is Free, Starter at $50/month, and Team at $200/month. Tembo is Free, Standard at $60/month, and Max at $200/month on a credit model. GitHub Copilot’s coding agent is included in paid Copilot plans and consumes AI credits plus Actions minutes. Ellipsis is usage-based with no per-seat fee. Nori Sessions is a flat $50 per runtime per month.
Do these agents remember my org’s context between runs?
Mostly through configuration you maintain: Devin uses playbooks, Charlie Labs uses DAEMON.md policy files, Ellipsis versions agent config as YAML in your repo, and Copilot reads repository instruction files. These work, but they are per-agent or per-repo settings you keep in sync. Nori Sessions loads every fresh machine with your org’s skillsets — durable instructions, memory, and tools — so agents show up already knowing how your team works.
What is the difference between a coding agent and an agent runtime?
A coding agent is the worker that reads code and proposes changes. An agent runtime is the machine, triggers, integrations, org context, and human workspace it runs inside. Many products give you a strong agent bolted to a thin runtime, so you still wire up scheduling, chat control, credentials, and org conventions yourself. Nori Sessions ships the full runtime — triggers, chat-native control, durable context, and a real terminal plus editor — as one product.
Sources
- Devin pricing — Cognition
- Devin Scheduled Sessions — Devin Docs
- Devin Slack integration — Devin Docs
- Introducing Daemons — Charlie Labs
- Charlie Labs pricing — Charlie Labs
- Tembo pricing — Tembo
- About the Copilot coding agent — GitHub Docs
- Copilot usage-based billing — GitHub Blog
- Ellipsis pricing — Ellipsis
- CodeRabbit Agent for Slack — CodeRabbit
Related guides
- Top Remote & Ephemeral Dev Sandboxes in 2026 — the ephemeral machines these agents run inside, and who presses start.
- Top AI Coding Agent Runtimes & Sandboxes in 2026 — the isolation layer beneath every unattended run: Firecracker, gVisor, and millisecond boots.
- All guides — every comparison guide in one place.